agentleFS
infeniainfenia/yukta/plugins/CLAUDE.md

yukta / plugins

CLAUDE.md1 starsChanged 20 days agoApache-2.0View on GitHub

The file

We split this CLAUDE.md into the rules it gives an agent

1 rule. About 0 are common, 0 are distinctive, and 1 is very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈0

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 1

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Follow the tiered "Test Execution Policy (speed)" in the root CLAUDE.md: run --tests for the classes you changed first.

    line 45

≈ “Common” is an estimate: at least 1 in 5 of the 27,641 CLAUDE.md files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
CLAUDE.md

Plugins CLAUDE.md

Overview

Implementations of various Yukta plugins.

Plugin Types

  • Processors: Located in processors/. Modules: process-executor, internal/internal-core, http-request (HTTP_REQUEST), file-io (FILE_READ/FILE_WRITE, sandboxed to baseDir), AGENT_SESSION (in process-executor, EXTENDED + restricted: runs an agent harness (Claude Code) on a prompt through ProcessExecutorGateway; ports success/failure/incomplete, payload {status, reason, text, sessionId, turn, exitCode}; session (a key; the same key resumes the harness from the token the last turn left; one turn at a time per key, onBusy WAIT or FAIL; in memory behind AgentSessionStore; approvals: ASK runs the harness over a stdin conversation (ProcessExecutorGateway.executeInteractive, preset interactive block: for Claude Code --input-format stream-json --permission-prompt-tool stdio) and turns each tool-use request into an APPROVAL on InputGateway, AgentApprovals; refusal on no answer); a harness is a JSON preset in agent-harnesses/ on the classpath or in yukta.ai.presets-dir, adding one needs no Java; harness options and the usage pattern list the presets), sql-query (SQL_QUERY, parameterized JDBC; driver supplied by deployer), internal-core also has DELAY, WAIT_FOR_SIGNAL (waits for signal_node / REST signal; a signal that comes first is kept for the wait; open waits are listed at GET /api/sessions/{s}/approvals), SUB_WORKFLOW (runs a workflow of the same session through SubWorkflowGateway, results from its terminals), VALIDATE, AGGREGATE, llm-call (LLM_CALL, Spring AI: OpenAI-compatible/Anthropic/Ollama), mcp-tool-call (MCP_LIST_TOOLS lists a server's tools for the tools option of LLM_CALL, which returns the model's native tool calls in actions; MCP_TOOL_CALL, MCP client over streamable HTTP; allowedTools refuses any other tool, e.g. one picked by a model (requireApproval lists tools, or *, that wait for a signal_node answer first (approvalSignal, approvalTimeoutSeconds); LLM_CALL can refuse prompts and answers with yukta.llm.deny-input-patterns, deny-output-patterns and max-input-chars, space calls per provider with yukta.llm.rate-limit.<provider> (requests per minute), end the whole run with budget.hardStop, and send earlier tool exchanges (actions on an assistant turn, {role: tool, toolCallId, toolName, content} turns); gateway-level yukta.mcp-client.allowed-tools, max-argument-bytes and deny-argument-patterns apply to every node), and a WAIT_FOR_SIGNAL node in front adds a human approval; session cache, SSE progress heartbeat, cancel, idempotency _meta). Sample chat-agent workflow: bruno/SessionConfigController/Apply Chat Agent Session.bru.
  • Decision processors (processors/decision, optional plugin decision): constrained model decisions for routing and gating, with Ollama System One (backend: SYSTEMONE, default, calibrated probabilities, local) or any chat model (backend: LLM + provider openai/anthropic/ollama, via llm-call's LlmGateway; probabilities are the model's own estimate, uncalibrated). Types: CLASSIFY (labels, optional routeByLabel, uncertain port), GATE (yes/no, pass/reject), SCORE (levels, optional high/low), ASK (up to 64 questions in one call), ANOMALY and DEDUPE (compare with the last N items of the node's run; normal/anomalous, unique/duplicate). Results go in metadata under into. A model failure fails the message; use the node's engine policy (retry, onError) for retries and dead letters. The backends are DecisionBackend beans (SystemOneModel kind SYSTEMONE, ChatDecisionModel kind LLM), picked by DecisionModels through the backend option; they implement AiBackend (plugin-api), which GET /api/ai/backends and the list_ai_backends MCP tool list with their options. Enabling it also pulls in LLM_CALL. System One needs Ollama 0.35+ and a decision model such as tev1:0.8b; keep descriptions of labels/levels explicit, a small model needs them.
  • Community plugins (external, optional plugin external, depends on process-executor via ModuleRules.ALLOWED): ExternalPlugins (a PluginSource) reads yukta-plugin.json manifests from yukta.plugins.dir and registers an ExternalProcessorPlugin or ExternalTerminalPlugin for each type named in yukta.plugins.enabled (TYPE or TYPE@sha256:<PluginDigest>; all does not cover them). CommandRun runs the command once per message through ProcessExecutorGateway.executeInstalled: envelope v1 on stdin (declared config fields only, resolved), stderr to the log, stdout lines checked against message-out.schema.json. run.image runs <runtime> run --rm -i --name yukta-<type>-<uuid> <yukta.plugins.container.args.TYPE> <image> through the same path (Containers: image inspected or pulled at startup, rm -f on timeout or cancel, only the CLI's own variables such as DOCKER_HOST added). run.mcp (McpRun, depends on mcp-tool-call via ModuleRules.ALLOWED): over stdio (command or image) StdioMcp, a hand-written JSON-RPC client over one long-lived process started with ProcessExecutorGateway.executeInstalledInteractive (clean env; the MCP SDK's stdio transport would pass the whole environment), restarted after it exits; over HTTP (url) HttpMcp through McpClientGateway. At startup the tool's input schema is read: its properties become config fields (McpTools.fields) and the pin is McpTools.digest(dir digest, schema). Config resolved per message = the tool's arguments; payload = structuredContent or text; isError fails the message. ExternalPlugins.close() stops the servers. Guide: ../docs/guides/extend/write-a-community-plugin.mdx; design: ../design/plans/community-plugins.md.
  • Triggers: Located in triggers/. Modules: api-trigger, constant-source, schedule-trigger (SCHEDULE_TRIGGER, interval/cron).
  • Terminals: Located in terminals/. Modules: console-terminal, notify-terminal (NOTIFY_TERMINAL, Slack-compatible JSON webhook).
  • Supervisor engines: Located in supervisors/. Modules: rules (type rules: declarative JSON/SpEL rules, presets failure-guard, stall-watchdog, approval-gate, timed every rules; the rule-supervisor bean is enabled by yukta.supervisor.rules.file but owns nothing), and process-engine (type process, JSON lines on stdin/stdout; yukta.process.allowed-commands). Engines depend on plugin-api only (ArchUnit). Rules can also answer or escalate input requests (then.answer, then.escalate; only with canAnswer/maxRisk, never HIGH); example: ../examples/16-supervisor-profiles/input-requests.json, loaded by InputRulesExampleTest. The control planes (rule, model, rules-first) were removed in S7.

Tiers and enabling

Every plugin has getTier() (CORE, EXTENDED, SPECIFIC; default CORE) and isRestricted() (reaches outside the engine). PluginRegistry registers CORE and unrestricted EXTENDED plugins always; SPECIFIC and restricted ones only when named in yukta.plugins.enabled (env YUKTA_PLUGINS_ENABLED, a list of types, or all). GET /api/plugins and the list_plugins / get_plugin_details MCP tools show every plugin with tier, restricted, enabled and enableWith, and a workflow that uses a disabled type fails validation with the setting to change. PluginTierAcceptanceTest lists every plugin: a new one must be classified there. boot tests run with all.

Config schema

Declare getConfigSchema() (see ConfigField) on a plugin to get a generated config form in the UI. Every plugin that takes configuration declares one (API_TRIGGER and CONSOLE_TERMINAL take none); a new plugin without a schema falls back to the JSON editor and the usage pattern. Keep field names equal to the keys the plugin reads, and add a test pinning the names and which are required.

Conformance kit

boot's PluginConformanceSweepTest runs PluginConformance (plugin-api test fixtures) over every registered plugin: schema vs. config, bad config gives a clear error, minimal config runs, cancel reaches the input and leaks no thread, a 10 MB message, an upstream error, no secret in logs. A new plugin fails that test until you either add a fixture (a minimal hermetic config, plus INPUTS if it reads input fields) to fixtures() in the test, or a reason to boot/src/test/resources/conformance-exemptions.properties. A SECRET schema field gets a canary value, so declare secrets with ConfigField.Type.SECRET.

Build Commands

# Build a specific plugin
yk gradle :plugins:processors:process-executor:build

Development

Each plugin should implement the interfaces defined in plugin-api. Guide: ../docs/contributing/modules/plugins.mdx (module guide); open risks, bugs and review findings: GitHub issues labelled plugins (gh issue list -l plugins; risks also carry risk); evolution path and quality lenses: ../design/assessments/plugins.md.

Conformance check

boot/.../plugins/PluginConformanceAcceptanceTest checks every registered plugin against the plugin contract (type name, category, config schema, output ports, timeout and buffer defaults, a description, validateConfig rejecting an empty config when a field is required, no crash on validateConfig or shutdown). A new plugin is covered with no test change; PluginCoverageAcceptanceTest still needs its type listed. If a plugin must break a rule, add "TYPE: rule" -> reason to EXEMPT in the conformance test.

Runtime check

boot/.../plugins/PluginRuntimeAcceptanceTest runs every plugin that does not need the outside world and checks that a cancel reaches the upstream, that a 10 MB message is handled or refused cleanly, and that initialize and shutdown can repeat. A new plugin must add a fixture (type to a valid config, in FIXTURES) or a reasoned entry in EXEMPT (for example, it calls an LLM or a URL); the test fails otherwise.

Imports

@.claude/rules/coding-standards.md @.claude/rules/git-workflow.md

Testing speed

Follow the tiered "Test Execution Policy (speed)" in the root CLAUDE.md: run --tests for the classes you changed first; full :plugins:test only when many files changed.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.