marketplace

KO | EN

gitlite — search

#javascript #typescript #machine-learning #deep-learning #linux #docker #java #windows #kubernetes #pytorch #ios #mcp #openai #open-source

(★ 11)

Marketplace for Wiolett plugins for LLM agents

marketplace Latest Version Download

Download Latest Version (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Wiolett Industries Agent Plugins

![Wiolett Industries Agent Plugins](https://s3.wiolett.net/static/net/wiolett/gh/marketplace/gh-marketplace-banner-2.png)

Unified marketplace source for [Wiolett Industries](https://wiolett.net)
agent plugins.

This repository ships Codex, Claude Code, and Kimi Code plugin metadata
together. Platform-specific manifests and agent definitions are committed so
users can install directly without running generators or setup commands.

## Why

Most skill packs are easier for humans to browse than for models to execute:
rules repeat, workflows get split into too many tiny skills, and context fills
up with prose that sounds nice but does not change behavior.

This marketplace takes the opposite bias: fewer moving parts, less prompt
sludge, and more explicit state. `workflow` keeps engineering work in clear
phases, `agent-memory` makes project knowledge durable and commit-friendly,
and `merge-request-review` adds stricter review artifacts and note drafts.

The goal is boring infrastructure for agents: workflow, memory, review
discipline, and shared knowledge future sessions should not have to rediscover.

## Ask Your Agent

Documentation is useful, but you do not have to read it first. Ask your agent
to inspect the marketplace for you:

```text
Read https://raw.githubusercontent.com/wiolett-industries/marketplace/main/llms.txt
and tell me which Wiolett plugin I should install for my workflow.
```

[`llms.txt`](./llms.txt) is the compact agent-facing guide: what this
marketplace is, what each plugin does, how to install it, and what model/auth
setup is required.

## Quick Start

Register the marketplace, install the plugins you want, then configure model
access for Agent Memory if you want gated writes, embeddings, semantic search,
and graph-link review.

Codex:

```bash
codex plugin marketplace add wiolett-industries/marketplace
```

Claude Code:

```text
/plugin marketplace add wiolett-industries/marketplace
/plugin install agent-memory@wiolett-industries
/plugin install workflow@wiolett-industries
/plugin install merge-request-review@wiolett-industries
```

Kimi Code:

```text
/plugins install https://github.com/wiolett-industries/marketplace
/reload
```

Agent Memory auth:

```bash
npx -y @wiolett/agent-memory@latest init
```

## Interactive CLI

After installation, Agent Memory can be configured and maintained from one
interactive terminal UI:

```bash
npx -y @wiolett/agent-memory@latest
```

On a new machine, this command starts the initialization flow first and does
not write files until the final confirmation. Once providers and enabled model
routes are configured, it opens a menu for configuration, memory
consolidation, model-usage reporting, and Doctor diagnostics. Direct shortcuts
such as `config`, `consolidate`, `usage`, and `doctor` remain available.

## Plugins

- [`agent-memory`](./plugins/agent-memory) - persistent scoped memory with
  compiled recall, automatic graph links, graph pathfinding, health/prune
  maintenance, and a local read-only dashboard
- [`workflow`](./plugins/workflow) - one-path risk-budgeted workflow with a
  zero-agent fast path, chat-only quick audits, production UI contracts,
  selective execution, single-pass verification, and explicit stop gates
- [`merge-request-review`](./plugins/merge-request-review) - discussion-aware
  ready GitLab MR review with CI-first evidence, zero-agent normal review by
  default, bounded high-risk agents, and one clean-pass approval

## Install In Codex

```bash
codex plugin marketplace add wiolett-industries/marketplace
```

For local development:

```bash
codex plugin marketplace add /absolute/path/to/local/marketplace
```

Then install the plugins you want from Codex.

## Install In Claude Code

```text
/plugin marketplace add wiolett-industries/marketplace
```

Then install the plugins you want:

```text
/plugin install agent-memory@wiolett-industries
/plugin install workflow@wiolett-industries
/plugin install merge-request-review@wiolett-industries
```

## Install In Kimi Code

Kimi Code installs this repository as one aggregate `wiolett-industries`
plugin. The aggregate includes the Agent Memory, Workflow, and Merge Request
Review skills and MCP servers:

```text
/plugins install https://github.com/wiolett-industries/marketplace
/reload
```

Installing, enabling, disabling, or updating a Kimi plugin takes effect after
`/reload` or in a new session. All three Wiolett components are installed
together, but their MCP servers can be enabled or disabled independently:

```text
/plugins mcp disable wiolett-industries merge-request-review
/reload
```

The same aggregate is also available through the repository's Kimi marketplace
catalog:

```text
/plugins marketplace https://raw.githubusercontent.com/wiolett-industries/marketplace/main/.kimi-plugin/marketplace.json
```

Kimi uses the shared portable `SKILL.md` files and Kimi-native inline MCP
declarations. It does not load the Codex TOML agents or Claude Code plugin
agents; workflows run locally by default and may use Kimi's built-in `explore`,
`plan`, or `coder` agents only within the same task-wide budget. The Kimi
manifest registers only the bounded Workflow `Stop` guard. Claude/Codex hook
configuration remains separate, and the Claude `PostToolUse` output filter is
not registered because Kimi treats that event as observation-only.

## Model Access

Only `agent-memory` needs a model key. `workflow` and `merge-request-review`
store local workflow state and do not call a model provider directly.

Their Codex custom agents route bounded work to GPT-5.6 Luna, everyday
implementation/review to Terra, and complex/high-risk work to Sol. Skills use
semantic work classes rather than model names, and parent Max/Ultra never
increases the task-wide agent budget. These are Codex session model selections,
not MCP provider credentials.

Agent Memory uses an OpenAI-compatible key for:

- model-gated memory writes
- AI-generated memory slugs and summaries
- compiled recall/query answers and broad memory recaps
- automatic graph-link review
- embeddings and semantic search

Configure it interactively:

```bash
npx -y @wiolett/agent-memory@latest init
```

Or configure it non-interactively:

```bash
npx -y @wiolett/agent-memory@latest init \
  --key "sk-proj-..." \
  --endpoint "https://api.openai.com/v1" \
  --text-api responses \
  --response-model "gpt-5.6-luna" \
  --embedding-model "text-embedding-3-small"
```

Agent Memory creates and owns these English-commented YAML files:

```text
~/.agents/.wiolett/config/ai-providers.yml
~/.agents/.wiolett/config/mcp-config.yml
```

The provider file is written with `0600` permissions. Workflow and Merge
Request Review only read their artifact-root sections and use their existing
defaults when shared configuration is absent.

Provider transport and credentials live in `ai-providers.yml`:

```yaml
version: 1
providers:
  openai:
    driver: openai
    base_url: https://api.openai.com/v1
    auth:
      api_key: sk-proj-...
    apis:
      responses:
        path: /responses
        store: false
      chat_completions:
        path: /chat/completions
      embeddings:
        path: /embeddings
```

Role routing and MCP storage live in `mcp-config.yml`. Embeddings, the write
gate, and synthesis may use different providers and models. Workflow and MR
review artifact roots are configurable there as well.

The same locked idempotent migration runs from both `agent-memory init` and
Agent Memory MCP startup. It converts the legacy JSON config and moves
`~/.agents/agent-memory` to `~/.agents/.wiolett/global-memory` (or the configured
path), preserving a timestamped backup and a compatibility symlink.

Other providers work when they implement the configured OpenAI-compatible
endpoints. Depending on role routing, Agent Memory calls:

- `POST /responses` with Bearer-token auth and OpenAI Responses-style output
- `POST /chat/completions` with Chat Completions request/response conversion
- `POST /embeddings` returning numeric embedding vectors
- the configured embedding model, or the default `text-embedding-3-small`
- the configured response model, or Agent Memory's default `gpt-5.6-luna`, or a provider
  alias that accepts that model name

Without a key, durable memory files still work, but model-gated writes,
semantic search, embeddings, AI slugs, and graph-link review are disabled or
fall back to cheaper local behavior where possible.

## Project Memory Belongs In Git

Project `.memory/` is repository-owned team knowledge, not a generated cache
directory. Commit memories, indexes, embeddings, graph edges, and reconciliation
metadata under
`.memory/memories/`, `.memory/index/`, `.memory/embeddings/`, and
`.memory/graph/`, and `.memory/maintenance/`. Never ignore `.memory/` wholesale.

Only the local SQLite cache and its sidecars should be ignored:

```gitignore
.memory/memory.db*
```

That single pattern covers `memory.db`, `memory.db-shm`, and `memory.db-wal`.

## Agent Memory Dashboard

Inspect a project or global memory store visually:

```bash
npx -y @wiolett/agent-memory@latest view
npx -y @wiolett/agent-memory@latest view global
```

## Repository Layout

- Plugin overview: [`plugins/README.md`](./plugins/README.md)
- Package overview: [`packages/README.md`](./packages/README.md)
- Codex marketplace: [`.agents/plugins/marketplace.json`](./.agents/plugins/marketplace.json)
- Claude Code marketplace: [`.claude-plugin/marketplace.json`](./.claude-plugin/marketplace.json)
- Kimi Code aggregate manifest: [`kimi.plugin.json`](./kimi.plugin.json)
- Kimi Code marketplace: [`.kimi-plugin/marketplace.json`](./.kimi-plugin/marketplace.json)
- Codex plugin manifests: `plugins/*/.codex-plugin/plugin.json`
- Claude Code plugin manifests: `plugins/*/.claude-plugin/plugin.json`
- Kimi Code per-plugin manifests: `plugins/*/kimi.plugin.json`
- Codex workflow/MR agents: `packages/*/agents/*.toml`
- Claude Code workflow/MR agents: `plugins/*/agents/*.md`

The platform-specific files are intentionally committed. Kimi currently
packages skills and MCP servers but not custom agents from a plugin manifest,
so its compatibility instructions map bounded delegation to Kimi's built-in
agents instead of copying Codex or Claude agent definitions. Maintainers may
use generators in the future, but generated outputs must stay in git so install
and runtime behavior remain turnkey.

## Development

```bash
pnpm install
pnpm test
pnpm typecheck
```

See [CONTRIBUTING.md](./CONTRIBUTING.md) for repository conventions and
[SECURITY.md](./SECURITY.md) for private vulnerability reporting.

## License

You can copy and paste the MIT license summary from below.

```text
MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```

marketplace

marketplace Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

marketplace

marketplace Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

Download README