yandecode 0.1.1 → 0.2.0

package/dist/chunks/chunk-7L6DD2VD.js

@@ -0,0 +1,768 @@
+import { createRequire as __yandecodeCreateRequire } from 'node:module';
+const require = __yandecodeCreateRequire(import.meta.url);
+import {
+  external_exports,
+  libdocsModule
+} from "./chunk-Y2MIXROU.js";
+
+// packages/cli/src/modules/code/definition.ts
+var maxChars = external_exports.number().int().min(200).max(4e4).optional().describe("Answer size budget in characters (rows are cut whole)");
+var searchInput = {
+  query: external_exports.string().min(1).max(500),
+  mode: external_exports.enum(["auto", "symbol", "path", "text"]).optional(),
+  path: external_exports.string().optional().describe("Restrict symbol search to a file or directory"),
+  limit: external_exports.number().int().min(1).max(50).optional(),
+  max_chars: maxChars
+};
+var symbolsInput = { path: external_exports.string().min(1), max_chars: maxChars };
+var definitionInput = {
+  name_path: external_exports.string().min(1),
+  path: external_exports.string().optional(),
+  max_chars: maxChars
+};
+var referencesInput = { name_path: external_exports.string().min(1), max_chars: maxChars };
+var repoMapInput = {
+  focus: external_exports.string().optional().describe("Only files under this path prefix"),
+  max_chars: maxChars
+};
+var codeModule = {
+  id: "code",
+  title: "Code navigation",
+  summary: "Symbol-level search, outlines, definitions, references and repo map (tree-sitter + BM25 + import graph)",
+  requires: [],
+  defaultEnabled: true,
+  guidance: "Navigate code with `code_search` (symbol names, `Class/method` paths, file fragments or plain words), `code_symbols` for a file outline, `code_definition` for one symbol body and `code_references` for usages; use `repo_map` to orient in an unfamiliar area. Read whole files only when these are not enough.",
+  routing: [
+    {
+      intent: "Find where something is defined or handled (function, type, error code, feature, file)",
+      use: "code_search(query)",
+      insteadOf: "grep -rn / rg / find"
+    },
+    {
+      intent: "See what a source file contains before reading it",
+      use: "code_symbols(path)",
+      insteadOf: "Read or cat of the whole file"
+    },
+    {
+      intent: "Read one function, method or type",
+      use: "code_definition(name_path)",
+      insteadOf: "sed -n 'a,bp' / Read with offsets"
+    },
+    {
+      intent: "Find callers or usages of a symbol",
+      use: "code_references(name_path)",
+      insteadOf: 'grep -rn "name"'
+    },
+    {
+      intent: "Get oriented in an unfamiliar area of the code",
+      use: "repo_map(focus)",
+      insteadOf: "ls -R / tree / reading many files"
+    }
+  ],
+  hooks: [{ event: "PreToolUse", matcher: "Grep|Glob|Read|Bash" }],
+  tools: [
+    {
+      name: "code_search",
+      title: "Find code",
+      description: "Instead of grep/rg/find over source code: find where a function, type, constant, error code or feature is defined or handled. Accepts an identifier, a Class/method path, a file-name fragment or a plain-English question; returns compact path:line rows with signatures, never whole files.",
+      inputSchema: searchInput
+    },
+    {
+      name: "code_symbols",
+      title: "Outline a file",
+      description: "Instead of reading a whole source file to see what is in it: list its functions, classes and methods with line ranges and signatures, so you can then read only the symbol you need (code_definition).",
+      inputSchema: symbolsInput
+    },
+    {
+      name: "code_definition",
+      title: "Read one symbol",
+      description: `Instead of sed -n 'a,bp', cat or Read with offsets: return the full source of one function, method or type by name (e.g. "Parser/parse_expr" or "lex_number"), numbered and read fresh from disk.`,
+      inputSchema: definitionInput
+    },
+    {
+      name: "code_references",
+      title: "Find usages",
+      description: "Instead of grep for a name: every line that uses a symbol (whole-identifier match, definition excluded) plus the files that import it. Lexical and fast; use lsp_references for type-aware precision in TS/JS/Python.",
+      inputSchema: referencesInput
+    },
+    {
+      name: "repo_map",
+      title: "Map the repository",
+      description: "Instead of ls -R, tree or opening many files to get oriented: the most central files (ranked by imports), each with its top-level declarations, within a size budget. Pass focus to narrow to a directory.",
+      inputSchema: repoMapInput
+    }
+  ],
+  skills: [],
+  agents: [],
+  cli: (program) => {
+    const code = program.command("code").description("Code navigation index");
+    code.command("index").description("Bring the code index up to date and print what changed").action(async () => {
+      const { runIndexCommand } = await import("./runtime-DBNXBOAL.js");
+      await runIndexCommand(process.cwd());
+    });
+    code.command("search <query...>").description("Search code from the terminal (same as the code_search MCP tool)").action(async (query) => {
+      const { runSearchCommand } = await import("./runtime-DBNXBOAL.js");
+      await runSearchCommand(process.cwd(), query.join(" "));
+    });
+  },
+  load: async () => (await import("./runtime-DBNXBOAL.js")).runtime
+};
+
+// packages/cli/src/modules/context/definition.ts
+var maxChars2 = external_exports.number().int().min(300).max(4e4).optional();
+var runInput = {
+  command: external_exports.string().min(1).max(8e3).describe("Shell command, run in the project root by default"),
+  intent: external_exports.string().max(300).optional().describe('What you are looking for in the output (e.g. "failing tests and their errors")'),
+  cwd: external_exports.string().optional().describe("Working directory relative to the project root"),
+  timeout_s: external_exports.number().int().min(1).max(600).optional().describe("Default 120 s"),
+  max_chars: maxChars2
+};
+var fetchInput = {
+  url: external_exports.url(),
+  intent: external_exports.string().max(300).optional(),
+  max_chars: maxChars2
+};
+var searchInput2 = {
+  query: external_exports.string().min(1).max(300),
+  handle: external_exports.string().optional().describe("Limit to one stored output"),
+  limit: external_exports.number().int().min(1).max(30).optional()
+};
+var getInput = {
+  handle: external_exports.string().min(1),
+  from: external_exports.number().int().min(1).optional(),
+  to: external_exports.number().int().min(1).optional(),
+  max_chars: maxChars2
+};
+var contextSettings = external_exports.object({
+  /** Deny `curl URL` / `wget -O- URL` in Bash and point to ctx_fetch / ctx_run. */
+  denyNetworkFetch: external_exports.boolean().default(true),
+  /** One-time hint per session when a verbose command runs through Bash. */
+  hints: external_exports.boolean().default(true),
+  retentionDays: external_exports.number().int().min(1).max(365).default(7),
+  maxOutputMb: external_exports.number().int().min(1).max(200).default(20)
+});
+var contextModule = {
+  id: "context",
+  title: "Context isolation",
+  summary: "Runs noisy commands and fetches outside the context window; keeps full output searchable (ctx_run/ctx_fetch/ctx_search)",
+  requires: [],
+  defaultEnabled: true,
+  guidance: "Run commands whose output may be long (tests, builds, logs, git history, API calls) with `ctx_run` and fetch web pages with `ctx_fetch`: they return a digest and keep the full output; use `ctx_search` / `ctx_get` to read any part verbatim instead of re-running.",
+  routing: [
+    {
+      intent: "Run tests, a build, a linter or any command with long output",
+      use: "ctx_run(command, intent)",
+      insteadOf: "Bash, and never a background run you then wait for"
+    },
+    {
+      intent: "Look again at the output of a command already run",
+      use: "ctx_search(query, handle) / ctx_get(handle, from, to)",
+      insteadOf: "re-running the command"
+    },
+    {
+      intent: "Read a web page or API response",
+      use: "ctx_fetch(url, intent)",
+      insteadOf: "curl / WebFetch"
+    }
+  ],
+  hooks: [{ event: "PreToolUse", matcher: "Bash" }],
+  tools: [
+    {
+      name: "ctx_run",
+      title: "Run a command (output kept)",
+      description: "Instead of Bash for tests, builds, linters, logs, git history or anything with long output: runs the command to completion (no background run to wait for), stores the full output and returns the exit code plus the failing or intent-relevant lines. Short outputs come back verbatim.",
+      inputSchema: runInput
+    },
+    {
+      name: "ctx_fetch",
+      title: "Fetch a URL",
+      description: "Instead of curl or WebFetch: fetch a page or API response (HTML to text, JSON pretty-printed), store it and return only the parts matching intent.",
+      inputSchema: fetchInput
+    },
+    {
+      name: "ctx_search",
+      title: "Search stored output",
+      description: "Instead of re-running a command to look at its output again: search everything ctx_run/ctx_fetch stored (or one handle) and get matching line ranges.",
+      inputSchema: searchInput2
+    },
+    {
+      name: "ctx_get",
+      title: "Read stored output lines",
+      description: "Exact lines of a stored output by handle and range (verbatim, numbered).",
+      inputSchema: getInput
+    }
+  ],
+  skills: [],
+  agents: [],
+  cli: (program) => {
+    program.command("context").description("Stored command/web outputs").command("purge").description("Delete all stored outputs").action(async () => {
+      const { runPurgeCommand } = await import("./runtime-7CRR63B5.js");
+      runPurgeCommand(process.cwd());
+    });
+  },
+  load: async () => (await import("./runtime-7CRR63B5.js")).runtime
+};
+
+// packages/cli/src/modules/guard/definition.ts
+var adjudicatorSettings = external_exports.object({
+  mode: external_exports.enum(["off", "shadow", "enforce"]).default("off"),
+  model: external_exports.string().default("typesafe/jev-1.13"),
+  baseUrl: external_exports.string().default("https://openrouter.ai/api/alpha"),
+  denyConfidence: external_exports.number().min(0).max(1).default(0.8),
+  timeoutMs: external_exports.number().int().positive().default(8e3)
+});
+var guardSettings = external_exports.object({
+  /** Rule ids to turn off: secrets-in-command, secrets-in-content, credential-file, sudo, destructive-rm, disk, force-push, history-rewrite, commit-secrets. */
+  disabled: external_exports.array(external_exports.string()).default([]),
+  /**
+   * Optional Jev adjudicator for the ambiguous (warn) cases. Off by default; needs
+   * OPENROUTER_API_KEY in the environment. `shadow` only logs Jev's opinion, `enforce` acts on it.
+   */
+  adjudicator: adjudicatorSettings.default(adjudicatorSettings.parse({}))
+});
+var guardModule = {
+  id: "guard",
+  title: "Tool-call guard",
+  summary: "Blocks leaking secrets, reading credential files, sudo and destructive commands before they run (deterministic, fail-open)",
+  requires: [],
+  defaultEnabled: false,
+  guidance: "A guard checks tool calls for secrets, credential files and destructive commands. If it blocks something the user explicitly asked for, re-run with `# guard-ok: <reason>`; never use the override on your own initiative.",
+  hooks: [{ event: "PreToolUse", matcher: "Bash|Read|Write|Edit|MultiEdit|NotebookEdit" }],
+  skills: [],
+  agents: [],
+  load: async () => (await import("./runtime-ZGGF6RVA.js")).runtime
+};
+
+// packages/cli/src/shared/project-checks.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var STEPS = ["format", "typecheck", "lint", "test"];
+var SCRIPT_CANDIDATES = {
+  format: ["format:check", "fmt:check"],
+  typecheck: ["typecheck", "type-check", "tsc", "check-types"],
+  lint: ["lint"],
+  test: ["test"]
+};
+function packageManager(root) {
+  if (existsSync(join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(root, "yarn.lock"))) return "yarn";
+  if (existsSync(join(root, "bun.lockb")) || existsSync(join(root, "bun.lock"))) return "bun";
+  return "npm";
+}
+function nodeChecks(root) {
+  const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+  const scripts = pkg.scripts ?? {};
+  const pm = packageManager(root);
+  return STEPS.flatMap((step) => {
+    const name = SCRIPT_CANDIDATES[step].find((candidate) => candidate in scripts);
+    return name ? [{ step, command: `${pm} run ${name}` }] : [];
+  });
+}
+function pythonChecks(root) {
+  const pyproject = existsSync(join(root, "pyproject.toml")) ? readFileSync(join(root, "pyproject.toml"), "utf8") : "";
+  const checks = [];
+  if (pyproject.includes("[tool.mypy]")) checks.push({ step: "typecheck", command: "mypy ." });
+  if (pyproject.includes("[tool.ruff")) checks.push({ step: "lint", command: "ruff check ." });
+  if (pyproject.includes("[tool.pytest") || existsSync(join(root, "pytest.ini")))
+    checks.push({ step: "test", command: "pytest -q" });
+  return checks;
+}
+function detectChecks(root, overrides = {}) {
+  const explicit = STEPS.flatMap(
+    (step) => overrides[step] ? [{ step, command: overrides[step] }] : []
+  );
+  if (explicit.length > 0) return explicit;
+  if (existsSync(join(root, "package.json"))) return nodeChecks(root);
+  if (existsSync(join(root, "go.mod"))) {
+    return [
+      { step: "lint", command: "go vet ./..." },
+      { step: "test", command: "go test ./..." }
+    ];
+  }
+  if (existsSync(join(root, "Cargo.toml"))) {
+    return [
+      { step: "lint", command: "cargo clippy --quiet" },
+      { step: "test", command: "cargo test --quiet" }
+    ];
+  }
+  return pythonChecks(root);
+}
+
+// packages/cli/src/modules/knowledge/memory-file.ts
+var MEMORY_KINDS = ["decision", "pattern", "fact", "failure", "note", "session"];
+function unquote(value) {
+  const v = value.trim();
+  if (v.startsWith('"') && v.endsWith('"') && v.length >= 2) return JSON.parse(v);
+  if (v.startsWith("'") && v.endsWith("'") && v.length >= 2)
+    return v.slice(1, -1).replace(/''/g, "'");
+  return v;
+}
+function parseInlineList(value) {
+  const inner = value.trim().slice(1, -1).trim();
+  return inner === "" ? [] : inner.split(",").map((item) => unquote(item));
+}
+function parseFrontMatter(block) {
+  const out = /* @__PURE__ */ new Map();
+  let listKey = null;
+  for (const line of block.split("\n")) {
+    const item = /^\s+-\s+(.*)$/.exec(line);
+    if (item && listKey) {
+      out.get(listKey).push(unquote(item[1]));
+      continue;
+    }
+    const pair = /^([A-Za-z_][\w-]*):\s*(.*)$/.exec(line);
+    if (!pair) continue;
+    const [, key, raw] = pair;
+    listKey = null;
+    if (raw === "") {
+      out.set(key, []);
+      listKey = key;
+    } else if (raw.trim().startsWith("[")) out.set(key, parseInlineList(raw));
+    else out.set(key, unquote(raw));
+  }
+  return out;
+}
+var scalar = (fields, key) => {
+  const value = fields.get(key);
+  return typeof value === "string" && value !== "" ? value : null;
+};
+var list = (fields, key) => {
+  const value = fields.get(key);
+  return Array.isArray(value) ? value : typeof value === "string" && value !== "" ? [value] : [];
+};
+function parseMemory(text) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(text);
+  if (!match) throw new Error("memory file has no front matter block (--- \u2026 ---)");
+  const fields = parseFrontMatter(match[1]);
+  const id = scalar(fields, "id");
+  const title = scalar(fields, "title");
+  if (!id) throw new Error("memory front matter needs an id");
+  if (!title) throw new Error(`memory ${id} needs a title`);
+  const kind = scalar(fields, "kind") ?? "note";
+  return {
+    id,
+    title,
+    kind: MEMORY_KINDS.includes(kind) ? kind : "note",
+    durability: scalar(fields, "durability") === "ephemeral" ? "ephemeral" : "durable",
+    created: scalar(fields, "created") ?? "",
+    updated: scalar(fields, "updated") ?? scalar(fields, "created") ?? "",
+    expires: scalar(fields, "expires"),
+    supersedes: list(fields, "supersedes"),
+    tags: list(fields, "tags"),
+    sources: list(fields, "sources"),
+    body: match[2].replace(/^\n+/, "").replace(/\s+$/, "")
+  };
+}
+function formatScalar(value) {
+  return /^[\w./@-][\w ./@():-]*$/.test(value) && !/:\s|\s$/.test(value) ? value : JSON.stringify(value);
+}
+function formatList(key, items) {
+  const simple = items.every((i) => /^[\w./@:#-]+$/.test(i));
+  if (simple) return `${key}: [${items.join(", ")}]`;
+  return [`${key}:`, ...items.map((i) => `  - ${JSON.stringify(i)}`)].join("\n");
+}
+function serializeMemory(memory) {
+  const lines = [
+    `id: ${memory.id}`,
+    `title: ${formatScalar(memory.title)}`,
+    `kind: ${memory.kind}`,
+    `durability: ${memory.durability}`,
+    `created: ${memory.created}`,
+    `updated: ${memory.updated}`,
+    ...memory.expires ? [`expires: ${memory.expires}`] : [],
+    ...memory.supersedes.length > 0 ? [formatList("supersedes", memory.supersedes)] : [],
+    ...memory.tags.length > 0 ? [formatList("tags", memory.tags)] : [],
+    ...memory.sources.length > 0 ? [formatList("sources", memory.sources)] : []
+  ];
+  return `---
+${lines.join("\n")}
+---
+${memory.body}
+`;
+}
+
+// packages/cli/src/modules/knowledge/definition.ts
+var searchInput3 = {
+  query: external_exports.string().min(1).max(500),
+  scope: external_exports.enum(["all", "docs", "memory"]).optional(),
+  limit: external_exports.number().int().min(1).max(30).optional(),
+  include_superseded: external_exports.boolean().optional()
+};
+var getInput2 = {
+  ids: external_exports.array(external_exports.string().min(1)).min(1).max(20).describe('Memory ids, or doc references "path" / "path:start-end" from knowledge_search'),
+  max_chars: external_exports.number().int().min(300).max(4e4).optional()
+};
+var writeInput = {
+  title: external_exports.string().min(3).max(160).describe("One-line statement of the knowledge"),
+  body: external_exports.string().min(1).max(8e3).describe("Why / details / how to apply; concise"),
+  kind: external_exports.enum(MEMORY_KINDS).describe("decision, pattern, fact, failure (with root cause), note"),
+  durability: external_exports.enum(["durable", "ephemeral"]).optional(),
+  tags: external_exports.array(external_exports.string()).max(10).optional(),
+  sources: external_exports.array(external_exports.string()).max(20).optional().describe("Evidence: repo paths (path:line), commits, URLs, ctx handles"),
+  supersedes: external_exports.array(external_exports.string()).max(10).optional().describe("Ids this memory replaces"),
+  expires_in_days: external_exports.number().int().min(1).max(365).optional()
+};
+var forgetInput = { id: external_exports.string().min(1) };
+var knowledgeSettings = external_exports.object({
+  /** Where memory files live, relative to the project root (commit it to share with the team). */
+  memoryDir: external_exports.string().default(".yandecode/memory"),
+  /** Absolute directories of extra Markdown to index (e.g. personal notes). */
+  extraDirs: external_exports.array(external_exports.string()).default([]),
+  sessionStartChars: external_exports.number().int().min(0).max(7e3).default(3e3),
+  /** Record edits/commands during a session and save an ephemeral summary at SessionEnd. */
+  capture: external_exports.boolean().default(true),
+  /** Point at related memories when a prompt mentions their subject. */
+  promptRecall: external_exports.boolean().default(true),
+  sessionTtlDays: external_exports.number().int().min(1).max(365).default(14)
+});
+var knowledgeModule = {
+  id: "knowledge",
+  title: "Knowledge & memory",
+  summary: "Project docs + persistent memory across sessions (decisions, patterns, failures) with progressive disclosure",
+  requires: [],
+  defaultEnabled: true,
+  guidance: "Before re-deriving project knowledge, `knowledge_search` docs and memory (returns ids/titles) and `knowledge_get` the few you need. Record durable decisions, gotchas and failure root causes with `memory_write` (cite sources; supersede instead of contradicting).",
+  routing: [
+    {
+      intent: "Find a past decision, convention or known pitfall, or read project docs",
+      use: "knowledge_search(query)",
+      insteadOf: "grep over *.md or guessing"
+    },
+    {
+      intent: "Record a decision, gotcha or failure root cause for later sessions",
+      use: "memory_write(title, body, kind)",
+      insteadOf: "leaving it only in this conversation"
+    }
+  ],
+  hooks: [
+    { event: "SessionStart" },
+    { event: "UserPromptSubmit" },
+    { event: "PostToolUse", matcher: "Bash|Edit|Write|MultiEdit|NotebookEdit|mcp__yandecode__.*" },
+    { event: "SessionEnd" }
+  ],
+  tools: [
+    {
+      name: "knowledge_search",
+      title: "Search docs and memory",
+      description: "Instead of grepping *.md files or re-deriving what the project decided: search project docs and remembered decisions, conventions and failures. Returns ids and titles; read details with knowledge_get.",
+      inputSchema: searchInput3
+    },
+    {
+      name: "knowledge_get",
+      title: "Read docs or memories",
+      description: 'Full text of memories (by id, with sources and staleness) or doc sections ("path:start-end") found with knowledge_search.',
+      inputSchema: getInput2
+    },
+    {
+      name: "memory_write",
+      title: "Remember for later sessions",
+      description: "Save a decision, convention, gotcha or failure root cause so future sessions know it. Near-duplicates are merged; durable by default.",
+      inputSchema: writeInput
+    },
+    {
+      name: "memory_forget",
+      title: "Forget a memory",
+      description: "Delete a memory that is wrong or useless (prefer supersedes when it was replaced).",
+      inputSchema: forgetInput
+    }
+  ],
+  skills: ["yandecode-memory"],
+  agents: [],
+  load: async () => (await import("./runtime-WAFQWW4M.js")).runtime
+};
+
+// packages/cli/src/modules/lsp/definition.ts
+var path = external_exports.string().min(1).describe("File path relative to the project root");
+var maxChars3 = external_exports.number().int().min(300).max(2e4).optional();
+var referencesInput2 = {
+  path,
+  name_path: external_exports.string().optional().describe('Symbol declared in `path`, e.g. "AuthService/login"'),
+  line: external_exports.number().int().min(1).optional().describe("1-based; with column, instead of name_path"),
+  column: external_exports.number().int().min(1).optional(),
+  max_chars: maxChars3
+};
+var definitionInput2 = {
+  path,
+  line: external_exports.number().int().min(1),
+  column: external_exports.number().int().min(1)
+};
+var diagnosticsInput = { path, max_chars: maxChars3 };
+var lspSettings = external_exports.object({
+  /** Install missing language servers into the user cache on first use. */
+  autoInstall: external_exports.boolean().default(true)
+});
+var lspModule = {
+  id: "lsp",
+  title: "Language servers",
+  summary: "Compiler-accurate references, go-to-definition and diagnostics via TypeScript/JavaScript and Python language servers",
+  requires: [],
+  defaultEnabled: false,
+  guidance: "When a rename or signature change must find every caller, or you need type errors for a file you edited, use `lsp_references` / `lsp_definition` / `lsp_diagnostics` (precise, slower to start) instead of lexical search.",
+  requirements: [
+    "npm registry access the first time a language server is used (installed into the user cache), unless typescript-language-server / pyright-langserver is already installed"
+  ],
+  routing: [
+    {
+      intent: "Find every real caller before changing a signature (TS/JS/Python)",
+      use: "lsp_references(path, name_path)",
+      insteadOf: "grep for the name"
+    },
+    {
+      intent: "Check an edited TS/JS/Python file for type errors",
+      use: "lsp_diagnostics(path)",
+      insteadOf: "running the full build"
+    }
+  ],
+  hooks: [],
+  tools: [
+    {
+      name: "lsp_references",
+      title: "Type-aware references",
+      description: "Instead of grep when a rename or signature change must find every real caller (TypeScript/JavaScript/Python): references according to the language server, cross-file and type-aware. Identify the symbol by name_path within path, or by line/column.",
+      inputSchema: referencesInput2
+    },
+    {
+      name: "lsp_definition",
+      title: "Go to definition",
+      description: "Where the symbol at path:line:column is defined, following imports and types (TypeScript/JavaScript/Python).",
+      inputSchema: definitionInput2
+    },
+    {
+      name: "lsp_diagnostics",
+      title: "Compiler diagnostics",
+      description: "Instead of running the whole build to see if an edited file still type-checks: the type errors and warnings the language server reports for that file now (TypeScript/JavaScript/Python).",
+      inputSchema: diagnosticsInput
+    }
+  ],
+  skills: [],
+  agents: [],
+  cli: (program) => {
+    const lsp = program.command("lsp").description("Language servers used by the lsp module");
+    lsp.command("install [language]").description("Install a language server (typescript, python) into the user cache").action(async (language) => {
+      const { runInstallCommand } = await import("./runtime-EY6SVZYP.js");
+      process.exitCode = await runInstallCommand(language);
+    });
+  },
+  load: async () => (await import("./runtime-EY6SVZYP.js")).runtime
+};
+
+// packages/cli/src/modules/quality/definition.ts
+var checkInput = {
+  steps: external_exports.array(external_exports.enum(STEPS)).optional().describe("Subset of format, typecheck, lint, test (default: all detected)"),
+  timeout_s: external_exports.number().int().min(10).max(1800).optional().describe("Per step, default 600")
+};
+var qualitySettings = external_exports.object({
+  /** Override detected commands, e.g. { "test": "make test" }. */
+  commands: external_exports.partialRecord(external_exports.enum(STEPS), external_exports.string()).default({}),
+  /** Security pattern warnings after edits. */
+  editWarnings: external_exports.boolean().default(true)
+});
+var qualityModule = {
+  id: "quality",
+  title: "Quality & security review",
+  summary: "Runs the project checks (quality_check), warns on risky code right after edits, and ships code/security review agents",
+  requires: [],
+  defaultEnabled: true,
+  guidance: "Verify with `quality_check` before claiming work is done (it runs the project typecheck/lint/tests and returns only failures). For reviews use the yandecode-code-review skill; report only findings you are confident about.",
+  routing: [
+    {
+      intent: "Verify the work before saying it is done",
+      use: "quality_check()",
+      insteadOf: "guessing or running the checks by hand"
+    }
+  ],
+  hooks: [{ event: "PostToolUse", matcher: "Write|Edit|MultiEdit|NotebookEdit" }],
+  tools: [
+    {
+      name: "quality_check",
+      title: "Run project checks",
+      description: "Instead of remembering and running the project's typecheck, lint and test commands one by one: runs them (detected or configured) to completion and returns pass/fail per step with only the failing lines.",
+      inputSchema: checkInput
+    }
+  ],
+  skills: ["yandecode-code-review", "yandecode-security-review"],
+  agents: ["yandecode-reviewer", "yandecode-security-reviewer"],
+  load: async () => (await import("./runtime-EKHO2JXB.js")).runtime
+};
+
+// packages/cli/src/modules/router/definition.ts
+var routerSettings = external_exports.object({
+  model: external_exports.string().default("typesafe/jev-1.13"),
+  baseUrl: external_exports.string().default("https://openrouter.ai/api/alpha"),
+  /** Emit a routing hint only when Jev is at least this sure (below it, stay silent). */
+  minConfidence: external_exports.number().min(0).max(1).default(0.7),
+  /** Prompts shorter than this are treated as chit-chat and never sent to Jev. */
+  minPromptChars: external_exports.number().int().nonnegative().default(12),
+  timeoutMs: external_exports.number().int().positive().default(6e3)
+});
+var routerModule = {
+  id: "router",
+  title: "Intent router",
+  summary: "Classifies each turn with Jev and points to the matching YandeCode tool (opt-in, needs OPENROUTER_API_KEY, fail-open)",
+  requires: [],
+  defaultEnabled: false,
+  guidance: "When a turn matches one of the YandeCode tools, an intent router adds a one-line hint naming it. The hint is advisory \u2014 use the named tool when it fits, or ignore it.",
+  hooks: [{ event: "UserPromptSubmit" }],
+  skills: [],
+  agents: [],
+  load: async () => (await import("./runtime-CKMVHAU4.js")).runtime
+};
+
+// packages/cli/src/modules/workflow/definition.ts
+var newInput = {
+  title: external_exports.string().min(3).max(120),
+  why: external_exports.string().min(1).max(4e3).describe("The problem and who has it"),
+  what: external_exports.string().max(4e3).optional().describe("What changes (bullets)")
+};
+var statusInput = {
+  id: external_exports.string().optional().describe("Omit to list all active changes")
+};
+var nextInput = { id: external_exports.string().min(1) };
+var checkInput2 = {
+  id: external_exports.string().min(1),
+  task_id: external_exports.string().min(1),
+  evidence: external_exports.string().max(500).optional().describe('How it was verified, e.g. "vitest: 12 passed"')
+};
+var archiveInput = { id: external_exports.string().min(1) };
+var workflowSettings = external_exports.object({
+  /** Where change folders live; defaults to openspec/changes if present, else docs/changes. */
+  changesDir: external_exports.string().optional()
+});
+var workflowModule = {
+  id: "workflow",
+  title: "Development workflow",
+  summary: "Brainstorm \u2192 spec \u2192 plan \u2192 TDD \u2192 verify, with resumable change folders (OpenSpec-shaped) and task tracking",
+  requires: [],
+  defaultEnabled: true,
+  guidance: "For non-trivial work follow the yandecode-workflow skill: `work_new` a change, write the plan into its tasks.md, implement task by task with TDD (`work_next` / `work_check` with evidence). `work_status` shows where any change stands after an interruption.",
+  routing: [
+    {
+      intent: "Work through the tasks of a change (docs/changes or openspec/changes)",
+      use: "work_next(id), then work_check(id, task_id, evidence)",
+      insteadOf: "reading and editing tasks.md by hand"
+    }
+  ],
+  hooks: [{ event: "SessionStart" }],
+  tools: [
+    {
+      name: "work_new",
+      title: "Start a change",
+      description: "Create a change folder (proposal.md with Why/What) for work that spans several steps or sessions.",
+      inputSchema: newInput
+    },
+    {
+      name: "work_status",
+      title: "Change status",
+      description: "Where a change (or every active change) stands: stage and task progress, derived from its files.",
+      inputSchema: statusInput
+    },
+    {
+      name: "work_next",
+      title: "Next task",
+      description: "Instead of reading tasks.md by hand: the next unchecked task of a change with its acceptance criteria and notes.",
+      inputSchema: nextInput
+    },
+    {
+      name: "work_check",
+      title: "Check off a task",
+      description: "Instead of editing tasks.md by hand: mark a task done after verifying it and log the evidence.",
+      inputSchema: checkInput2
+    },
+    {
+      name: "work_archive",
+      title: "Archive a change",
+      description: "Move a finished change to the archive.",
+      inputSchema: archiveInput
+    }
+  ],
+  skills: ["yandecode-workflow", "yandecode-tdd", "yandecode-debugging", "yandecode-verification"],
+  agents: [],
+  load: async () => (await import("./runtime-UB2O2HUN.js")).runtime
+};
+
+// packages/cli/src/modules/instructions/definition.ts
+var instructionsModule = {
+  id: "instructions",
+  title: "Project instructions",
+  summary: "Audits CLAUDE.md/AGENTS.md (size, broken paths, unknown commands, duplicates) and reports project conventions",
+  requires: [],
+  defaultEnabled: true,
+  guidance: "After editing CLAUDE.md or AGENTS.md, run `instructions_audit` and fix what it reports; keep instruction files short (commands, non-obvious rules) and move long guidance into skills or docs.",
+  routing: [
+    {
+      intent: "Check CLAUDE.md / AGENTS.md after editing them",
+      use: "instructions_audit()",
+      insteadOf: "reviewing them by eye"
+    }
+  ],
+  hooks: [],
+  tools: [
+    {
+      name: "instructions_audit",
+      title: "Audit agent instructions",
+      description: "After editing CLAUDE.md or AGENTS.md: report their token cost, references to missing files or scripts, duplicated rules and the detected project conventions.",
+      inputSchema: {}
+    }
+  ],
+  skills: ["yandecode-instructions"],
+  agents: [],
+  cli: (program) => {
+    program.command("instructions").description("Agent instruction files").command("audit").description("Audit CLAUDE.md / AGENTS.md (same as the instructions_audit tool)").action(async () => {
+      const { runAuditCommand } = await import("./runtime-3E4NIFAL.js");
+      process.exitCode = runAuditCommand(process.cwd());
+    });
+  },
+  load: async () => (await import("./runtime-3E4NIFAL.js")).runtime
+};
+
+// packages/cli/src/modules/registry.ts
+var MODULES = [
+  codeModule,
+  lspModule,
+  contextModule,
+  knowledgeModule,
+  libdocsModule,
+  qualityModule,
+  workflowModule,
+  instructionsModule,
+  guardModule,
+  routerModule
+];
+
+export {
+  searchInput,
+  symbolsInput,
+  definitionInput,
+  referencesInput,
+  repoMapInput,
+  codeModule,
+  runInput,
+  fetchInput,
+  searchInput2,
+  getInput,
+  contextSettings,
+  guardSettings,
+  detectChecks,
+  parseMemory,
+  serializeMemory,
+  searchInput3,
+  getInput2,
+  writeInput,
+  forgetInput,
+  knowledgeSettings,
+  referencesInput2,
+  definitionInput2,
+  diagnosticsInput,
+  lspSettings,
+  checkInput,
+  qualitySettings,
+  routerSettings,
+  newInput,
+  statusInput,
+  nextInput,
+  checkInput2,
+  archiveInput,
+  workflowSettings,
+  MODULES
+};
+//# sourceMappingURL=chunk-7L6DD2VD.js.map