@opvs-ai/cli 0.22.0 → 0.24.1

package/README.md

@@ -288,6 +288,79 @@ Needs the `code:read` scope, which is in the default ceiling. There is no
 `opvs code index` command on purpose — writing an index is `code:write`, which
 a worker PAT does not carry, and the ingest caller is the sidecar on the desk.
 
+### Skill lessons
+
+Pull and contribute the lessons a skill's collectors left in the typed marketplace
+(AS-590). The reference is `<vendor>/<name>` (a leading `@` on the vendor is
+optional); the CLI validates it locally before any request.
+
+```bash
+opvs memory lessons get opvs-ai/opvs-vibe               # Pull a skill's lessons
+opvs memory lessons get opvs-ai/opvs-vibe --query retry  # FTS over body + tags
+opvs memory lessons get opvs-ai/opvs-vibe --limit 50 --since cur-1
+
+opvs memory lessons add opvs-ai/opvs-vibe \
+  --kind learning \
+  --body "Retry on 429 with jitter; never under 200ms"
+
+opvs memory lessons add opvs-ai/opvs-vibe \
+  --kind pattern --body-file ./note.md --tags "retry,http"
+```
+
+`add` ships five keys exactly — `kind`, `body`, `tags`, `source_engagement_hash`,
+`craft_id` — because the server-side `CraftContribute` schema sets
+`extra="forbid"` (AS-445 sealed anything that looked like a credential). The
+provenance hash is `sha256("cli:" + workspace_slug + ":" + body)` and NEVER
+carries a brand id.
+
+### Runtime memory hooks
+
+Install the SessionStart memory hook for Codex, the complete checked-in plugin
+hook set for Claude Code, the OPVS MCP read path and capture hooks for Cursor,
+or a managed capture plugin for OpenCode or Cline. Existing JSON entries are
+merged and repeated installs are no-ops.
+
+```bash
+opvs memory install codex
+opvs memory install claude-code
+opvs memory install cursor
+opvs memory install opencode
+opvs memory install cline
+opvs memory install codex --project       # writes ./.codex/hooks.json
+opvs memory install cursor --project      # writes ./.cursor/{mcp,hooks}.json
+opvs memory install opencode --project    # writes ./.opencode/plugins/opvs-memory.ts
+opvs memory uninstall codex               # removes only OPVS memory hooks
+opvs memory uninstall cursor              # removes only OPVS MCP/hooks entries
+opvs memory uninstall cline               # removes only the managed OPVS plugin
+opvs memory uninstall codex --project
+```
+
+User-level Codex hooks use `$CODEX_HOME/hooks.json` (default
+`~/.codex/hooks.json`). User-level Claude Code hooks use
+`$CLAUDE_CONFIG_DIR/settings.json` (default `~/.claude/settings.json`), with
+the plugin hook set merged under its `hooks` key. `--project` uses
+`./.codex/hooks.json` or `./.claude/settings.json` in the current project.
+Installing the bundled Claude Code plugin through Claude Code's plugin
+installer is an alternative to `opvs memory install claude-code`; plugins load
+their own `hooks/hooks.json` as part of plugin installation.
+
+Cursor uses `~/.cursor/mcp.json` and `~/.cursor/hooks.json`, or the matching
+project files with `--project`. The MCP entry starts `opvs-mcp`, which provides
+the OPVS memory read tools. The installed `postToolUse`, `stop`, and
+`sessionEnd` hooks feed the same local capture pipeline as Claude Code.
+
+OpenCode installs `opvs-memory.ts` under
+`~/.config/opencode/plugins/` (or `./.opencode/plugins/` with `--project`).
+Cline installs it under `~/.cline/plugins/` (or `./.cline/plugins/` with
+`--project`). Each file is marked as OPVS-managed, so uninstall will not remove
+an unmarked file or any other plugin in the directory. The plugins forward
+tool-after and idle/run-end events to `opvs memory hook` with a two-second
+timeout and fail open. They only upload capture data after the user explicitly
+runs `opvs memory capture on`.
+Installing hooks does **not** enable capture: run `opvs memory capture on` with
+a dedicated PAT whose only scope is `memory:ingest`, and use
+`opvs memory capture off` to remove that local PAT again.
+
 ### Session
 
 ```bash

package/claude-plugin/.claude-plugin/marketplace.json

@@ -0,0 +1,14 @@
+{
+  "name": "opvs",
+  "description": "OPVS plugins for agent workflows",
+  "owner": {
+    "name": "OPVS"
+  },
+  "plugins": [
+    {
+      "name": "opvs-memory",
+      "source": "./",
+      "description": "Read relevant typed memories and record new lessons from Claude Code."
+    }
+  ]
+}

package/claude-plugin/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "opvs-memory",
+  "displayName": "OPVS Memory",
+  "version": "0.1.0",
+  "description": "Loads relevant typed memories at session start and provides memory tools and a remember workflow.",
+  "author": {
+    "name": "OPVS"
+  }
+}

package/claude-plugin/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "opvs": {
+      "command": "npx",
+      "args": ["-y", "@opvs-ai/mcp"]
+    }
+  }
+}

package/claude-plugin/README.md

@@ -0,0 +1,24 @@
+# OPVS Memory for Claude Code
+
+This plugin loads relevant typed memories when a Claude Code session starts, exposes the OPVS memory MCP tools, and provides the `/opvs-memory:remember` skill for recording a validated lesson in the current repository.
+
+## Prerequisites
+
+- Install and authenticate the OPVS CLI (`opvs auth request ...`).
+- Use a PAT with `memory:read` scope.
+- Have Node.js available so Claude Code can launch `@opvs-ai/mcp`.
+
+## Install from this checkout
+
+From the repository root:
+
+```sh
+claude plugin marketplace add ./packages/cli/claude-plugin
+claude plugin install opvs-memory@opvs
+```
+
+Start a new Claude Code session after installation. The SessionStart hook calls `opvs memory hook session-start`; when memory is unavailable or the CLI is not logged in, it stays silent and does not block startup.
+
+Use `/opvs-memory:remember` to record a lesson. The skill follows `memory/SPEC.md`, writes with exclusive-create semantics, and refuses to overwrite an existing entry.
+
+The plugin starts the published MCP server with `npx -y @opvs-ai/mcp`. The server reads the same local OPVS authentication as the CLI; no credential is stored in this plugin.

package/claude-plugin/hooks/hooks.json

@@ -0,0 +1,50 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear|compact|fork",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "opvs memory hook session-start",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "opvs memory hook post-tool",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "opvs memory hook stop",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "opvs memory hook session-end",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}

package/claude-plugin/skills/remember/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: remember
+description: Record a durable, typed lesson in the repository's registered service planning folder.
+argument-hint: "<lesson to remember>"
+disable-model-invocation: true
+allowed-tools: Read, Grep, Bash
+---
+
+# Remember a lesson
+
+Use this workflow only for a durable lesson supported by evidence. Do not use it for a preference, guess, secret, credential, or temporary task state.
+
+1. Read `memory/SPEC.md` sections 2, 3, and 5 and `memory/services.yaml` in the current repository.
+2. Identify the registered service whose `planning_dir` owns the lesson. Use that service id and planning directory; do not invent either value.
+3. Turn the lesson into one standalone core line. Collect the required `evidence`, runnable `verify`, expected result, and a control that makes verification fail. Ask the user for any required value that cannot be established from the session.
+4. Run the writer below from the repository root. Pass the active card ref as `--card`; if there is no card, explain that this writer requires one and stop. Quote every value as a separate shell argument.
+
+```sh
+node "${CLAUDE_PLUGIN_ROOT}/skills/remember/scripts/remember.mjs" \
+  --service "<service-id>" \
+  --planning-dir "<registered-planning-dir>" \
+  --card "<CARD-123>" \
+  --core "<one-line lesson>" \
+  --topic "<short topic>" \
+  --evidence "<observed evidence>" \
+  --verify "<SPEC-compliant command>" \
+  --expect "<SPEC-compliant expectation>" \
+  --control "<change that makes verification fail>"
+```
+
+The writer derives the UTC date and branch slug, creates one file with exclusive-create semantics, and prints its relative path. Read the generated file and check its header, routing line, and core line before reporting success. Never overwrite, move, or delete an existing memory entry.

package/claude-plugin/skills/remember/scripts/remember.mjs

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { isAbsolute, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+function required(value, name) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`${name} is required`);
+  }
+  return value.trim();
+}
+
+function oneLine(value, name) {
+  const checked = required(value, name);
+  if (/\r|\n/.test(checked)) throw new Error(`${name} must be one line`);
+  return checked;
+}
+
+function slug(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+
+function yamlString(value) {
+  return JSON.stringify(value);
+}
+
+export function buildLesson(input) {
+  const date = required(input.date, "date");
+  const card = required(input.card, "card");
+  const service = required(input.service, "service");
+  const branchSlug = slug(required(input.branch, "branch"));
+  const core = oneLine(input.core, "core");
+  const topic = slug(required(input.topic, "topic"));
+  const evidence = oneLine(input.evidence, "evidence");
+  const verify = oneLine(input.verify, "verify");
+  const expect = oneLine(input.expect, "expect");
+  const control = oneLine(input.control, "control");
+  const confidence = input.confidence ?? 0.9;
+
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) throw new Error("date must be YYYY-MM-DD");
+  if (!/^[A-Z][A-Z0-9]*-\d+$/.test(card)) throw new Error("card must look like ABC-123");
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(service)) {
+    throw new Error("service must be a lower-case service id");
+  }
+  if (!branchSlug) throw new Error("branch must produce a slug");
+  if (typeof confidence !== "number" || confidence < 0 || confidence > 1) {
+    throw new Error("confidence must be between 0 and 1");
+  }
+
+  const stem = `${date}-${card}-${branchSlug}`;
+  const filename = `${stem}.md`;
+  const detail = typeof input.detail === "string" && input.detail.trim()
+    ? `\n\n${input.detail.trim()}\n`
+    : "\n";
+  const text = `---
+id: ${service}/lesson/${stem}
+type: lesson
+author: session:${card}
+card: ${card}
+evidence: ${yamlString(evidence)}
+verify: ${yamlString(verify)}
+expect: ${yamlString(expect)}
+control: ${yamlString(control)}
+---
+@${service}>${service} . #lrn #${topic} $f:${confidence} $t:${date}
+${core}${detail}`;
+
+  return { filename, text };
+}
+
+export function writeLesson(input, options = {}) {
+  const cwd = resolve(options.cwd ?? process.cwd());
+  const planningDir = required(input.planningDir, "planning-dir");
+  if (isAbsolute(planningDir) || planningDir.split(/[\\/]+/).includes("..")) {
+    throw new Error("planning-dir must be a repository-relative path without '..'");
+  }
+  if (!planningDir.startsWith("docs/planning/")) {
+    throw new Error("planning-dir must name a registered docs/planning service folder");
+  }
+  const planningRoot = resolve(cwd, planningDir);
+  if (!existsSync(planningRoot) || relative(cwd, planningRoot).startsWith("..")) {
+    throw new Error("planning-dir must be an existing directory inside the repository");
+  }
+
+  const date = options.date ?? new Date().toISOString().slice(0, 10);
+  const branch = options.branch ?? execFileSync(
+    "git",
+    ["branch", "--show-current"],
+    { cwd, encoding: "utf8" },
+  ).trim();
+  const rendered = buildLesson({ ...input, date, branch });
+  const lessonsDir = resolve(planningRoot, "learnings");
+  mkdirSync(lessonsDir, { recursive: true });
+  const target = resolve(lessonsDir, rendered.filename);
+  writeFileSync(target, rendered.text, { encoding: "utf8", flag: "wx" });
+  return relative(cwd, target);
+}
+
+function parseArgs(argv) {
+  const values = {};
+  for (let index = 0; index < argv.length; index += 2) {
+    const flag = argv[index];
+    const value = argv[index + 1];
+    if (!flag?.startsWith("--") || value === undefined) {
+      throw new Error("arguments must be --name value pairs");
+    }
+    values[flag.slice(2).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase())] = value;
+  }
+  return values;
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === resolve(fileURLToPath(import.meta.url))) {
+  try {
+    const output = writeLesson(parseArgs(process.argv.slice(2)));
+    process.stdout.write(`${output}\n`);
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+  }
+}

package/dist/.build-stamp.json

@@ -1,9 +1,9 @@
 {
   "stamp_version": 1,
   "package": "@opvs-ai/cli",
-  "version": "0.22.0",
-  "source_digest": "688f710405153fa8948da5155d608cc39119da7c91d1647a34b8665f7df5b3ce",
-  "source_files": 45,
-  "built_at": "2026-09-30T19:14:41.962Z",
-  "node": "v22.23.2"
+  "version": "0.24.1",
+  "source_digest": "60073109ec4e93c4fdd6612c101b4ff3599bfec06d9959c2b51cf95882888409",
+  "source_files": 54,
+  "built_at": "2026-10-03T05:52:09.611Z",
+  "node": "v22.23.3"
 }

package/dist/commands/code-graph.d.ts

@@ -0,0 +1,17 @@
+/**
+ * opvs code graph — a node's import neighbourhood, built against the agreed route shape
+ * (TCI-113 · design §7).
+ *
+ * The CLI does not interpret the answer. It builds the URL the API contract describes
+ * (`GET /api/v1/code/{project_id}/graph`) and lets `printResponse` write the server's
+ * bytes — including a 422 when the server rejects `depth` or `limit`. That parity is
+ * what makes the "CLI and HTTP return the same YAML" claim testable rather than
+ * aspirational, the same property the `context` and `summary` subcommands have.
+ *
+ * ⚠️ Registration precondition. The `code` parent command must already be attached to
+ * the program. A silent no-op would ship a CLI without the command — the whole point
+ * of this file is to register `graph`, so a missing parent is a programmer error and
+ * we throw.
+ */
+import { Command } from "commander";
+export declare function registerCodeGraphCommand(program: Command): void;

package/dist/commands/code-graph.js

@@ -0,0 +1,64 @@
+/**
+ * opvs code graph — a node's import neighbourhood, built against the agreed route shape
+ * (TCI-113 · design §7).
+ *
+ * The CLI does not interpret the answer. It builds the URL the API contract describes
+ * (`GET /api/v1/code/{project_id}/graph`) and lets `printResponse` write the server's
+ * bytes — including a 422 when the server rejects `depth` or `limit`. That parity is
+ * what makes the "CLI and HTTP return the same YAML" claim testable rather than
+ * aspirational, the same property the `context` and `summary` subcommands have.
+ *
+ * ⚠️ Registration precondition. The `code` parent command must already be attached to
+ * the program. A silent no-op would ship a CLI without the command — the whole point
+ * of this file is to register `graph`, so a missing parent is a programmer error and
+ * we throw.
+ */
+import { getEffectiveConfig, createClient } from "@opvs-ai/core";
+import { buildUrl, printResponse } from "../lib/format.js";
+export function registerCodeGraphCommand(program) {
+    const code = program.commands.find((c) => c.name() === "code");
+    if (!code) {
+        throw new Error("registerCodeGraphCommand: 'code' command is not registered — call registerCodeCommands(program) first");
+    }
+    code
+        .command("graph <node_id>")
+        .description("A node's import neighbourhood — who imports it, what it imports, one or two hops")
+        .requiredOption("--project <id>", "Project id (board_groups.id where kind=project)")
+        .option("--direction <dir>", "in | out | both — which side of <node_id> to walk from")
+        .option("--depth <n>", "1 | 2 — server rejects 3+ with a 422")
+        .option("--limit <n>", "Max neighbours (server default 100, clamps at 500)")
+        .option("--branch <name>", "Answer from a specific indexed branch")
+        .option("--format <fmt>", "yaml | md | json — overrides the configured default")
+        .action(async (nodeId, opts) => {
+        const wsSlug = program.opts().workspace;
+        const cfg = getEffectiveConfig(wsSlug);
+        try {
+            const client = createClient(wsSlug);
+            // Send ONLY the options the user set. A `direction: undefined` would become
+            // `direction=undefined` on the wire and the server would read it as a real
+            // filter — the same `code context` defect (TCI-12) this card inherits.
+            const params = { node_id: nodeId };
+            if (opts.direction)
+                params.direction = opts.direction;
+            if (opts.depth)
+                params.depth = opts.depth;
+            if (opts.limit)
+                params.limit = opts.limit;
+            if (opts.branch)
+                params.branch = opts.branch;
+            // The server is the judge of `depth` (1/2 → 200, 3+ → 422) and `limit`
+            // (default 100, clamps at 500). Forwarding both verbatim is what lets a
+            // client discover the cap from the response, instead of having the CLI
+            // pre-mangle a request the API was built to refuse with a precise code.
+            const url = buildUrl(`/api/v1/code/${opts.project}/graph`, params, opts.format || cfg.format);
+            const res = await client.get(url);
+            await printResponse(res);
+        }
+        catch (err) {
+            const e = err;
+            console.error(`Error: ${e.detail || "Failed to query code graph"}`);
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=code-graph.js.map

package/dist/commands/code-graph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-graph.js","sourceRoot":"","sources":["../../src/commands/code-graph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAE3D,MAAM,UAAU,wBAAwB,CAAC,OAAgB;IACvD,MAAM,IAAI,GAAG,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,MAAM,CAAC,CAAC;IAC/D,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CACb,uGAAuG,CACxG,CAAC;IACJ,CAAC;IAED,IAAI;SACD,OAAO,CAAC,iBAAiB,CAAC;SAC1B,WAAW,CAAC,kFAAkF,CAAC;SAC/F,cAAc,CAAC,gBAAgB,EAAE,iDAAiD,CAAC;SACnF,MAAM,CAAC,mBAAmB,EAAE,wDAAwD,CAAC;SACrF,MAAM,CAAC,aAAa,EAAE,sCAAsC,CAAC;SAC7D,MAAM,CAAC,aAAa,EAAE,oDAAoD,CAAC;SAC3E,MAAM,CAAC,iBAAiB,EAAE,uCAAuC,CAAC;SAClE,MAAM,CAAC,gBAAgB,EAAE,qDAAqD,CAAC;SAC/E,MAAM,CAAC,KAAK,EAAE,MAAc,EAAE,IAAI,EAAE,EAAE;QACrC,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,SAAS,CAAC;QACxC,MAAM,GAAG,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;QACvC,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;YACpC,4EAA4E;YAC5E,2EAA2E;YAC3E,uEAAuE;YACvE,MAAM,MAAM,GAA2B,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;YAC3D,IAAI,IAAI,CAAC,SAAS;gBAAE,MAAM,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;YACtD,IAAI,IAAI,CAAC,KAAK;gBAAE,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;YAC1C,IAAI,IAAI,CAAC,KAAK;gBAAE,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;YAC1C,IAAI,IAAI,CAAC,MAAM;gBAAE,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;YAC7C,uEAAuE;YACvE,wEAAwE;YACxE,uEAAuE;YACvE,wEAAwE;YACxE,MAAM,GAAG,GAAG,QAAQ,CAClB,gBAAgB,IAAI,CAAC,OAAO,QAAQ,EACpC,MAAM,EACN,IAAI,CAAC,MAAM,IAAI,GAAG,CAAC,MAAM,CAC1B,CAAC;YACF,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAClC,MAAM,aAAa,CAAC,GAAG,CAAC,CAAC;QAC3B,CAAC;QAAC,OAAO,GAAY,EAAE,CAAC;YACtB,MAAM,CAAC,GAAG,GAA0B,CAAC;YACrC,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,MAAM,IAAI,4BAA4B,EAAE,CAAC,CAAC;YACpE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAClB,CAAC;IACH,CAAC,CAAC,CAAC;AACP,CAAC"}

package/dist/commands/code.d.ts

@@ -1,9 +1,10 @@
 /**
- * opvs code — the tenant code index query door (TCI · 2.2)
+ * opvs code — the tenant code index query door (TCI · 2.2 + 2.4)
  *
  * The question this answers is "does this already exist in the repo?", asked by
- * an agent that is about to write something. It is the CLI face of
- * `GET /api/v1/code/{project_id}/context` and `.../summary`.
+ * an agent that is about to write something. It is the CLI face of every read
+ * the API serves under `/api/v1/code/{project_id}/`: context, summary, tree,
+ * files, symbols, and the stable-node reads (resolve, changes).
  *
  * ⚠️ THE VERDICT IS NOT THE WHOLE ANSWER.
  * `indexed: false` and `verdict: "none"` are DIFFERENT facts and the API returns
@@ -18,6 +19,15 @@
  * scope ceiling. `code:write` (the ingest lane) is deliberately not, and there is
  * no CLI command for it: an index pass is a 50,000-row bulk load and a worker
  * session must not be able to spend one (D5).
+ *
+ * SEND ONLY WHAT THE USER SET (TCI-112, P2.4)
+ * ---------------------------------------------
+ * Every option here is optional except `--project`. The brief is explicit: do
+ * not invent a default the server did not ask for. A `branch=undefined` on the
+ * wire is a real filter reading as "the branch named 'undefined'"; a
+ * `directory=` left out of `/files` lets the API apply its own `.` default; a
+ * `format=undefined` is a literal string on the URL. Each `if (opts.x) ...`
+ * gate exists so the request the server sees is the request the user asked for.
  */
 import { Command } from "commander";
 export declare function registerCodeCommands(program: Command): void;