@bitfun-vsl/plugin 0.0.0-stage → 0.0.1

package/assets/claude-code/scripts/mcp-server.js

@@ -0,0 +1,741 @@
+// @bun
+// package.json
+var package_default = {
+  $schema: "https://json.schemastore.org/package.json",
+  name: "@bitfun-vsl/plugin",
+  version: "0.0.1",
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  type: "module",
+  license: "MIT",
+  description: "Shared modules and native host adapters for DevEco Code, Claude Code and BitFun",
+  repository: {
+    type: "git",
+    url: "git+https://gitcode.com/OpenBitFun/bitfun_horizon_verify.git"
+  },
+  homepage: "https://gitcode.com/OpenBitFun/bitfun_horizon_verify#readme",
+  scripts: {
+    prepack: "bun run build",
+    typecheck: "tsgo --noEmit",
+    test: "bun test",
+    "install:bitfun": "bun src/hosts/bitfun-kernel/commands.ts",
+    build: "bun run script/build.ts"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./plugin": {
+      types: "./dist/plugin/index.d.ts",
+      import: "./dist/plugin/index.js"
+    },
+    "./hosts/deveco": {
+      types: "./dist/hosts/deveco/plugin.d.ts",
+      import: "./dist/hosts/deveco/plugin.js"
+    },
+    "./server": {
+      types: "./dist/hosts/deveco/plugin.d.ts",
+      import: "./dist/hosts/deveco/plugin.js"
+    },
+    "./hosts/bitfun-kernel": {
+      types: "./dist/hosts/bitfun-kernel/plugin.d.ts",
+      import: "./dist/hosts/bitfun-kernel/plugin.js"
+    },
+    "./hosts/claude-code": {
+      types: "./dist/hosts/claude-code/index.d.ts",
+      import: "./dist/hosts/claude-code/index.js"
+    }
+  },
+  files: [
+    "dist",
+    "assets",
+    "README.md",
+    "docs/plugin-design.md",
+    "docs/init-installation.md",
+    "docs/code-review-integration.md"
+  ],
+  dependencies: {
+    "@inquirer/prompts": "^8.7.5",
+    "@opencode-ai/plugin": "1.17.9",
+    "jsonc-parser": "3.3.1"
+  },
+  devDependencies: {
+    "@tsconfig/bun": "1.0.9",
+    "@types/bun": "1.3.13",
+    "@types/node": "24.12.2",
+    typescript: "5.8.2",
+    "@typescript/native-preview": "7.0.0-dev.20251207.1"
+  },
+  bin: {
+    vsl: "dist/cli/index.js"
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// src/plugin/modules/trajectory-analysis.ts
+var inputSchema = {
+  type: "object",
+  properties: {
+    source: { type: "string", description: "\u8F68\u8FF9\u6587\u4EF6\u6216\u76EE\u5F55\uFF1Bmock \u6A21\u5F0F\u53EA\u7528\u4E8E\u6807\u8BC6\u8F93\u5165" }
+  },
+  required: ["source"],
+  additionalProperties: false
+};
+var sourceOf = (input) => {
+  if (!input || typeof input !== "object" || typeof input.source !== "string")
+    throw new Error("source must be a string");
+  return input.source;
+};
+var mockRead = async (input, context) => {
+  const source = sourceOf(input);
+  context.report("\u8BFB\u53D6\u8F68\u8FF9\uFF08mock\uFF09");
+  return {
+    title: "Trajectory loaded",
+    output: JSON.stringify({ source, events: 12, durationMs: 4800, mock: true }),
+    metadata: { source, mock: true }
+  };
+};
+var mockAnalyze = async (input, context) => {
+  const source = sourceOf(input);
+  context.report("\u5206\u6790\u8F68\u8FF9\uFF08mock\uFF09");
+  return {
+    title: "Trajectory analyzed",
+    output: JSON.stringify({ source, eventCount: 12, phases: 3, anomalies: 1, score: 0.92, mock: true }),
+    metadata: { source, eventCount: 12, phases: 3, anomalies: 1, score: 0.92, mock: true }
+  };
+};
+var mockReport = async (input, context) => {
+  const source = sourceOf(input);
+  context.report("\u751F\u6210\u8F68\u8FF9\u62A5\u544A\uFF08mock\uFF09");
+  return {
+    title: "Trajectory report ready",
+    output: `Mock trajectory report for ${source}: score=0.92, anomalies=1`,
+    metadata: { source, mock: true }
+  };
+};
+function createTrajectoryAnalysisModule() {
+  return {
+    id: "trajectory-analysis",
+    version: "0.1.0",
+    description: "\u63D0\u4F9B\u8F68\u8FF9\u8BFB\u53D6\u3001\u5206\u6790\u548C\u62A5\u544A\u80FD\u529B\u7684 mock \u6A21\u5757",
+    commands: [
+      {
+        name: "vsl:trajectory",
+        description: "\u5206\u6790\u6307\u5B9A\u8F68\u8FF9\u5E76\u751F\u6210\u5206\u6790\u7ED3\u679C",
+        agent: "vsl-trajectory",
+        template: [
+          "\u5206\u6790\u7528\u6237\u6307\u5B9A\u7684\u8F68\u8FF9\u3002",
+          "\u5148\u52A0\u8F7D vsl-trajectory-analysis Skill\u3002",
+          "\u5FC5\u987B\u8C03\u7528 vsl_trajectory_analyze\uFF0C\u4E0D\u8981\u4EC5\u6839\u636E\u5BF9\u8BDD\u5185\u5BB9\u63A8\u6D4B\u7ED3\u679C\u3002",
+          "\u7528\u6237\u53C2\u6570\uFF1A$ARGUMENTS"
+        ].join(`
+`),
+        toolNames: ["vsl_trajectory_analyze"]
+      }
+    ],
+    agents: [
+      {
+        name: "vsl-trajectory",
+        description: "\u8D1F\u8D23\u7EC4\u7EC7\u8F68\u8FF9\u5206\u6790\u5DE5\u5177\u8C03\u7528",
+        mode: "subagent",
+        prompt: "\u4F60\u8D1F\u8D23\u5206\u6790\u8F68\u8FF9\u3002\u5148\u52A0\u8F7D vsl-trajectory-analysis\uFF0C\u518D\u8C03\u7528\u786E\u5B9A\u6027\u7684\u8F68\u8FF9\u5DE5\u5177\u3002"
+      }
+    ],
+    skills: [
+      {
+        name: "vsl-trajectory-analysis",
+        description: "\u8F68\u8FF9\u683C\u5F0F\u3001\u5206\u6790\u6B65\u9AA4\u548C\u7ED3\u679C\u89E3\u91CA\u89C4\u5219",
+        content: [
+          "\u4F7F\u7528\u8F68\u8FF9\u5DE5\u5177\u5B8C\u6210\u5206\u6790\uFF0C\u4E0D\u8981\u6839\u636E\u5BF9\u8BDD\u731C\u6D4B\u6570\u636E\u3002",
+          "\u5148\u8C03\u7528 vsl_trajectory_read\uFF0C\u518D\u8C03\u7528 vsl_trajectory_analyze\uFF0C\u6700\u540E\u6309\u9700\u8C03\u7528 vsl_trajectory_report\u3002"
+        ].join(`
+`)
+      }
+    ],
+    tools: [
+      { name: "vsl_trajectory_read", description: "\u8BFB\u53D6\u5E76\u6821\u9A8C\u8F68\u8FF9\uFF08mock\uFF09", input: inputSchema, execute: mockRead },
+      { name: "vsl_trajectory_analyze", description: "\u6267\u884C\u8F68\u8FF9\u5206\u6790\uFF08mock\uFF09", input: inputSchema, execute: mockAnalyze },
+      { name: "vsl_trajectory_report", description: "\u751F\u6210\u8F68\u8FF9\u62A5\u544A\uFF08mock\uFF09", input: inputSchema, execute: mockReport }
+    ]
+  };
+}
+
+// src/plugin/schema.ts
+function validateInput(schema, input, path = "input") {
+  if (schema.type === "object") {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+      throw new Error(`${path} must be an object`);
+    const values = input;
+    schema.required?.forEach((key) => {
+      if (values[key] === undefined)
+        throw new Error(`${path}.${key} is required`);
+    });
+    Object.entries(values).forEach(([key, value]) => {
+      const property = schema.properties?.[key];
+      if (!property && schema.additionalProperties === false)
+        throw new Error(`${path}.${key} is not supported`);
+      if (property)
+        validateInput(property, value, `${path}.${key}`);
+    });
+    return;
+  }
+  if (schema.type === "array") {
+    if (!Array.isArray(input))
+      throw new Error(`${path} must be an array`);
+    if (schema.items)
+      input.forEach((value, index) => validateInput(schema.items, value, `${path}[${index}]`));
+    return;
+  }
+  if (schema.type === "integer" || schema.type === "number") {
+    if (typeof input !== "number" || !Number.isFinite(input) || schema.type === "integer" && !Number.isInteger(input))
+      throw new Error(`${path} must be a finite ${schema.type}`);
+    if (schema.minimum !== undefined && input < schema.minimum)
+      throw new Error(`${path} must be >= ${schema.minimum}`);
+    if (schema.maximum !== undefined && input > schema.maximum)
+      throw new Error(`${path} must be <= ${schema.maximum}`);
+    return;
+  }
+  if (typeof input !== schema.type)
+    throw new Error(`${path} must be a ${schema.type}`);
+  if (schema.enum && !schema.enum.includes(String(input)))
+    throw new Error(`${path} must be one of ${schema.enum.join(", ")}`);
+}
+
+// src/plugin/modules/code-review/runtime.ts
+import { spawn } from "child_process";
+import { createWriteStream } from "fs";
+import { access, mkdir, readFile, realpath, stat } from "fs/promises";
+import { homedir } from "os";
+import { delimiter, isAbsolute, join, resolve } from "path";
+import { pipeline } from "stream/promises";
+async function review(input, context, options) {
+  if (Boolean(input.from) !== Boolean(input.to))
+    throw new Error("from and to must be provided together");
+  if (input.commit && (input.from || input.to))
+    throw new Error("commit cannot be combined with from/to");
+  if (input.preview && input.resume)
+    throw new Error("preview cannot be combined with resume");
+  if (input.resume && !input.commit && !input.from)
+    throw new Error("resume requires commit or from/to; workspace resume is not supported");
+  const directory = await realpath(resolve(context.directory, input.repo ?? "."));
+  const args = ["review", "--repo", directory, "--audience", "agent", "--format", "json"];
+  const flags = {
+    commit: "commit",
+    from: "from",
+    to: "to",
+    resume: "resume",
+    background: "background",
+    backgroundFile: "background-file",
+    rule: "rule",
+    provider: "provider",
+    model: "model",
+    effort: "effort",
+    concurrency: "concurrency",
+    taskTimeoutMinutes: "timeout",
+    maxTokensBudget: "max-tokens-budget"
+  };
+  Object.entries(flags).forEach(([key, flag]) => {
+    const value = input[key];
+    if (value !== undefined)
+      args.push(`--${flag}`, String(value));
+  });
+  if (input.preview)
+    args.push("--preview");
+  if (input.exclude?.length)
+    args.push("--exclude", input.exclude.join(","));
+  context.report(input.preview ? "Previewing CR review scope" : "Running CR review");
+  const result = await runCr(await resolveCr(options.binary), args, {
+    directory,
+    signal: context.signal,
+    timeoutMs: (input.overallTimeoutMinutes ?? 60) * 60000,
+    cacheDirectory: options.cacheDirectory
+  });
+  return reviewResult(result, directory, input.preview);
+}
+async function reviewResult(result, directory, preview = false) {
+  const text = await readFile(result.resultFile, "utf8");
+  const parsed = await Promise.resolve().then(() => JSON.parse(text)).catch(() => {
+    return;
+  });
+  const payload = record(parsed);
+  const manifest = record(payload?.manifest);
+  const coverage = record(manifest?.coverage);
+  const terminal = manifest?.terminal_state;
+  const knownState = typeof terminal === "string" && ["complete", "partial", "failed", "skipped"].includes(terminal);
+  const validCoverage = ["selected", "completed", "reused", "failed", "waived"].every((key) => Array.isArray(coverage?.[key]));
+  const validReview = knownState && manifest?.schema_version === "cr.run-manifest/v1" && validCoverage && Array.isArray(payload?.comments);
+  const noFiles = !manifest && payload?.status === "skipped" && Array.isArray(payload.comments) && payload.comments.length === 0 && typeof payload.message === "string";
+  const validPreview = preview && typeof payload?.total_files === "number" && typeof payload.reviewable_count === "number" && Array.isArray(payload.files);
+  const diagnostic = (await readFile(result.stderrFile, "utf8")).slice(-4000);
+  const error = result.error || (result.exitCode !== 0 ? `CR exited with code ${result.exitCode}` : undefined) || (!(preview ? validPreview : validReview || noFiles) ? "CR returned empty, invalid, or incompatible JSON; review completion is unknown" : undefined);
+  const comments = Array.isArray(payload?.comments) ? payload.comments : [];
+  const metadata = {
+    repository: directory,
+    executable: result.executable,
+    exitCode: result.exitCode,
+    state: validReview ? terminal : !error && validPreview ? "preview" : !error && noFiles ? "skipped" : "error",
+    terminalState: knownState ? terminal : undefined,
+    message: typeof payload?.message === "string" ? payload.message.slice(0, 1000) : undefined,
+    sessionId: payload?.session_id,
+    resultFile: result.resultFile,
+    stderrFile: result.stderrFile
+  };
+  const output = JSON.stringify({
+    ...metadata,
+    error,
+    ...error ? { diagnostic } : {},
+    manifest,
+    summary: payload?.summary,
+    warnings: payload?.warnings,
+    resume: payload?.resume,
+    ...preview ? { preview: payload } : {
+      findingsCount: comments.length,
+      comments: text.length > 48000 ? [] : comments.slice(0, 30),
+      findingsTruncated: comments.length > 30 || text.length > 48000
+    }
+  });
+  return {
+    title: error ? "CR execution failed" : preview ? "CR preview ready" : `CR review: ${metadata.state}`,
+    isError: Boolean(error || terminal === "failed"),
+    metadata,
+    output: output.length <= 64000 ? output : JSON.stringify({
+      ...metadata,
+      error,
+      diagnostic: error ? diagnostic : undefined,
+      findingsCount: comments.length,
+      coverageCounts: Object.fromEntries(Object.entries(coverage ?? {}).filter(([, value]) => Array.isArray(value)).map(([key, value]) => [key, value.length])),
+      detailsTruncated: true,
+      findingsTruncated: !preview,
+      instruction: "Read resultFile in bounded batches for the complete review/preview, findings, warnings and coverage."
+    })
+  };
+}
+async function health(input, context, options) {
+  const executable = await resolveCr(options.binary);
+  const version = await runCr(executable, ["version"], { directory: context.directory, signal: context.signal, timeoutMs: 30000, cacheDirectory: options.cacheDirectory });
+  const help = await runCr(executable, ["review", "--help"], { directory: context.directory, signal: context.signal, timeoutMs: 30000, cacheDirectory: options.cacheDirectory });
+  const helpText = await readFile(help.resultFile, "utf8");
+  const compatible = ["--format", "--audience", "--preview", "--resume", "--max-tokens-budget"].every((flag) => helpText.includes(flag));
+  const connection = input.checkConnection ? await runCr(executable, ["llm", "test"], {
+    directory: context.directory,
+    signal: context.signal,
+    timeoutMs: 120000,
+    cacheDirectory: options.cacheDirectory
+  }) : undefined;
+  const isError = !compatible || [version, help, ...connection ? [connection] : []].some((item) => item.error || item.exitCode !== 0);
+  return {
+    title: isError ? "CR health check failed" : "CR is available",
+    isError,
+    output: JSON.stringify({
+      executable,
+      version: (await readFile(version.resultFile, "utf8")).trim(),
+      cliFlagsCompatible: compatible,
+      manifestCompatibility: "Validated against cr.run-manifest/v1 when an actual review runs",
+      modelConnection: connection ? { exitCode: connection.exitCode, error: connection.error, output: (await readFile(connection.resultFile, "utf8")).trim(), stderrFile: connection.stderrFile } : "not checked",
+      diagnostics: [version, help]
+    })
+  };
+}
+async function resolveCr(binary = process.env.VSL_CR_BIN) {
+  if (binary) {
+    if (!isAbsolute(binary))
+      throw new Error("VSL_CR_BIN must be an absolute path to the native CR executable");
+    if (/\.(cmd|bat|ps1|js)$/i.test(binary))
+      throw new Error("VSL_CR_BIN must point to the native executable, not a shell or npm shim");
+    await access(binary);
+    return realpath(binary);
+  }
+  const names = process.platform === "win32" ? ["cr.exe"] : ["cr"];
+  const candidates = (process.env.PATH ?? "").split(delimiter).filter(Boolean).flatMap((directory) => names.map((name) => join(directory, name)));
+  const found = await Promise.all(candidates.map(async (path) => await access(path).then(() => path, () => {
+    return;
+  })));
+  const executable = found.find((path) => path !== undefined);
+  if (!executable)
+    throw new Error("CR native executable not found. Install/build the review CLI and set VSL_CR_BIN to its absolute executable path.");
+  return realpath(executable);
+}
+async function runCr(executable, args, options) {
+  options.signal.throwIfAborted();
+  const directory = join(options.cacheDirectory ?? process.env.VSL_CR_CACHE_DIR ?? join(process.env.LOCALAPPDATA ?? process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache"), "vsl", "cr"), crypto.randomUUID());
+  await mkdir(directory, { recursive: true, mode: 448 });
+  const resultFile = join(directory, "result.json");
+  const stderrFile = join(directory, "stderr.log");
+  const child = spawn(executable, args, {
+    cwd: options.directory,
+    env: { ...process.env, CR_NO_UPDATE: "1" },
+    shell: false,
+    detached: process.platform !== "win32",
+    windowsHide: true,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let error;
+  let closed = false;
+  let forceTimer;
+  const kill = () => {
+    if (closed || !child.pid)
+      return;
+    if (process.platform === "win32") {
+      spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { windowsHide: true, stdio: "ignore" }).on("error", () => child.kill("SIGKILL"));
+      return;
+    }
+    try {
+      process.kill(-child.pid, "SIGTERM");
+    } catch {
+      child.kill("SIGTERM");
+    }
+    forceTimer = setTimeout(() => {
+      if (!closed && child.pid) {
+        try {
+          process.kill(-child.pid, "SIGKILL");
+        } catch {
+          child.kill("SIGKILL");
+        }
+      }
+    }, 3000);
+  };
+  const stop = (message) => {
+    if (error)
+      return;
+    error = message;
+    kill();
+  };
+  const abort = () => stop("CR execution cancelled");
+  const timer = setTimeout(() => stop("CR overall execution deadline exceeded"), options.timeoutMs);
+  options.signal.addEventListener("abort", abort, { once: true });
+  if (options.signal.aborted)
+    abort();
+  child.on("error", (cause) => {
+    error ??= `Cannot start CR: ${cause.message}`;
+  });
+  const streams = Promise.all([
+    pipeline(child.stdout, createWriteStream(resultFile, { mode: 384 })),
+    pipeline(child.stderr, createWriteStream(stderrFile, { mode: 384 }))
+  ]).catch((cause) => stop(`Cannot save CR output: ${cause instanceof Error ? cause.message : String(cause)}`));
+  let outputBytes = 0;
+  [child.stdout, child.stderr].forEach((stream) => stream.on("data", (chunk) => {
+    outputBytes += chunk.length;
+    if (outputBytes > 32 * 1024 * 1024)
+      stop("CR output exceeds 32 MiB; partial evidence retained on disk");
+  }));
+  const exitCode = await new Promise((done) => child.once("close", (code) => {
+    closed = true;
+    clearTimeout(timer);
+    clearTimeout(forceTimer);
+    options.signal.removeEventListener("abort", abort);
+    done(code);
+  }));
+  await streams;
+  const size = (await stat(resultFile)).size;
+  if (size > 32 * 1024 * 1024)
+    throw new Error(`CR JSON exceeds the 32 MiB parsing limit; full output: ${resultFile}; stderr: ${stderrFile}`);
+  return { executable, exitCode, resultFile, stderrFile, error };
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+
+// src/plugin/modules/code-review/index.ts
+var reviewSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    repo: { type: "string", description: "Repository path; defaults to the host project. In Claude pass the current project explicitly if MCP cwd differs." },
+    commit: { type: "string", description: "Single commit; mutually exclusive with from/to" },
+    from: { type: "string", description: "Base ref; requires to" },
+    to: { type: "string", description: "Target ref; requires from" },
+    preview: { type: "boolean", description: "Preview scope without calling the CR model" },
+    resume: { type: "string", description: "CR session ID; requires original commit or from/to; incompatible with preview" },
+    background: { type: "string" },
+    backgroundFile: { type: "string" },
+    rule: { type: "string" },
+    exclude: { type: "array", items: { type: "string" } },
+    provider: { type: "string" },
+    model: { type: "string" },
+    effort: { type: "string", enum: ["low", "medium", "high"] },
+    concurrency: { type: "integer", minimum: 1 },
+    taskTimeoutMinutes: { type: "integer", minimum: 1 },
+    maxTokensBudget: { type: "integer", minimum: 0 },
+    overallTimeoutMinutes: { type: "number", minimum: 0.001, maximum: 1440, description: "Whole process deadline, default 60 minutes; independent of CR per-task timeout" }
+  }
+};
+var healthSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: { checkConnection: { type: "boolean", description: "Explicitly test CR's configured model connection; default false" } }
+};
+function createCodeReviewModule(options = {}) {
+  return {
+    id: "code-review",
+    version: "0.1.0",
+    description: "Run the complete review engine through its native CLI",
+    commands: [
+      {
+        name: "vsl:review",
+        description: "Run a complete CR review of workspace, commit, or branch changes",
+        toolNames: ["vsl_cr_review"],
+        template: "Use vsl_cr_review to run the complete CR engine. Convert the user's scope to structured arguments; pass the current repository. Default to workspace review. CR uses its own model configuration. Report manifest terminal state and coverage; partial/skipped/failed are not complete. Preserve CR findings and severity; do not substitute your own review. If findingsTruncated or detailsTruncated is true, read resultFile in bounded batches before reporting results. Preview is scope only. Resume requires the original commit or from/to. Do not modify code or publish comments unless requested. User request: $ARGUMENTS"
+      },
+      {
+        name: "vsl:cr-health",
+        description: "Check CR executable, CLI compatibility, and optionally its model connection",
+        toolNames: ["vsl_cr_health"],
+        template: "Use vsl_cr_health. Only set checkConnection=true when the user asks to test the model connection. Report executable path, version, compatibility and diagnostics. User request: $ARGUMENTS"
+      }
+    ],
+    tools: [
+      {
+        name: "vsl_cr_review",
+        description: "Run the complete CR review engine with its own configured model. Read manifest coverage and terminal state; zero findings or exit 0 alone do not prove completion. Full raw output is retained in resultFile. Read that file if findingsTruncated. No code is changed by VSL.",
+        input: reviewSchema,
+        async execute(input, context) {
+          validateInput(reviewSchema, input);
+          return review(input, context, options);
+        }
+      },
+      {
+        name: "vsl_cr_health",
+        description: "Locate the native CR executable and check version/required CLI flags. Model connectivity is only tested when checkConnection=true.",
+        input: healthSchema,
+        async execute(input, context) {
+          validateInput(healthSchema, input);
+          return health(input, context, options);
+        }
+      }
+    ]
+  };
+}
+
+// src/plugin/registry.ts
+var assertUnique = (kind, names) => {
+  const seen = new Set;
+  const duplicate = names.find((name) => {
+    if (seen.has(name))
+      return true;
+    seen.add(name);
+    return false;
+  });
+  if (duplicate)
+    throw new Error(`${kind} conflict: ${duplicate}`);
+};
+function createModuleRegistry(input = {}) {
+  const modules = (input.modules ?? []).filter((module) => input.enabled?.[module.id] !== false);
+  if (new Set(modules.map((module) => module.id)).size !== modules.length)
+    throw new Error("module conflict");
+  const resources = {
+    modules,
+    commands: modules.flatMap((module) => module.commands ?? []),
+    agents: modules.flatMap((module) => module.agents ?? []),
+    skills: modules.flatMap((module) => module.skills ?? []),
+    tools: modules.flatMap((module) => module.tools ?? [])
+  };
+  assertUnique("command", resources.commands.map((item) => item.name));
+  assertUnique("agent", resources.agents.map((item) => item.name));
+  assertUnique("skill", resources.skills.map((item) => item.name));
+  assertUnique("tool", resources.tools.map((item) => item.name));
+  const agents = new Set(resources.agents.map((item) => item.name));
+  const tools = new Set(resources.tools.map((item) => item.name));
+  resources.commands.forEach((command) => {
+    if (command.agent && !agents.has(command.agent))
+      throw new Error(`command ${command.name} references missing agent ${command.agent}`);
+    command.toolNames?.forEach((tool) => {
+      if (!tools.has(tool))
+        throw new Error(`command ${command.name} references missing tool ${tool}`);
+    });
+  });
+  return {
+    enabled: () => resources,
+    command: (name) => resources.commands.find((item) => item.name === name),
+    tool: (name) => resources.tools.find((item) => item.name === name)
+  };
+}
+
+// src/runtime.ts
+import { readFileSync, existsSync } from "fs";
+import { dirname, join as join2, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+// assets/build.json
+var build_default = {
+  version: "0.0.1",
+  buildId: "bbceff2246e5fb0e4b93bb05081457dbc113400b937c6148764573618d8534b5"
+};
+
+// src/runtime.ts
+function packageRoot(url) {
+  const visit = (directory) => {
+    if (existsSync(join2(directory, ".vsl-runtime.json")))
+      return directory;
+    const manifest = join2(directory, "package.json");
+    if (existsSync(manifest) && JSON.parse(readFileSync(manifest, "utf8")).name === "@bitfun-vsl/plugin")
+      return directory;
+    if (dirname(directory) === directory)
+      throw new Error(`Cannot locate VSL package from ${url}`);
+    return visit(dirname(directory));
+  };
+  return visit(dirname(fileURLToPath(url)));
+}
+function runtimeConfig(root) {
+  const path = existsSync(join2(root, ".vsl-runtime.json")) ? join2(root, ".vsl-runtime.json") : join2(root, "assets/runtime.json");
+  if (!existsSync(path))
+    return;
+  const value = JSON.parse(readFileSync(path, "utf8"));
+  if (!value || typeof value !== "object" || !("schemaVersion" in value) || value.schemaVersion !== 1 || !("host" in value) || !["deveco", "claude-code", "bitfun"].includes(String(value.host)) || !("modules" in value) || !Array.isArray(value.modules) || !value.modules.every((item) => typeof item === "string") || !("installationId" in value) || typeof value.installationId !== "string" || "crBinary" in value && typeof value.crBinary !== "string")
+    throw new Error(`Invalid VSL runtime config: ${path}`);
+  return value;
+}
+function runtimeInfo(root, modules) {
+  return {
+    ...build_default,
+    packageRoot: resolve2(root),
+    installationId: runtimeConfig(root)?.installationId,
+    modules: modules.map((item) => ({ id: item.id, version: item.version }))
+  };
+}
+
+// src/plugin/index.ts
+function createRegistry(input = {}) {
+  return createModuleRegistry({ modules: input.modules ?? [createTrajectoryAnalysisModule(), createCodeReviewModule({ binary: input.crBinary })], enabled: input.enabled });
+}
+function createHostRegistry(root) {
+  const config = runtimeConfig(root);
+  const modules = createRegistry({ crBinary: process.env.VSL_CR_BIN ?? config?.crBinary }).enabled().modules;
+  const unknown = config?.modules.find((name) => !modules.some((module) => module.id === name));
+  if (unknown)
+    throw new Error(`Unknown VSL module: ${unknown}`);
+  const selected = modules.filter((module) => !config || config.modules.includes(module.id));
+  return createModuleRegistry({ modules: [...selected, {
+    id: "runtime",
+    version: "1.0.0",
+    description: "Installed host build identity",
+    tools: [{
+      name: "vsl_runtime_info",
+      description: "Report the VSL build actually loaded by this host; does not run a model or modify files.",
+      input: { type: "object", properties: {}, additionalProperties: false },
+      async execute() {
+        return { title: "VSL runtime", output: JSON.stringify(runtimeInfo(root, selected)) };
+      }
+    }]
+  }] });
+}
+
+// src/hosts/claude-code/mcp-server.ts
+function createMcpProtocol(options = {}) {
+  const tools = (options.registry ?? createHostRegistry(packageRoot(import.meta.url))).enabled().tools;
+  const byName = new Map(tools.map((item) => [item.name, item]));
+  const running = new Map;
+  return {
+    abortAll() {
+      running.forEach((controller) => controller.abort());
+    },
+    async handle(message) {
+      const respond = (result) => ({ jsonrpc: "2.0", id: message.id ?? null, result });
+      if (message.method === "notifications/cancelled") {
+        if (message.params?.requestId !== undefined)
+          running.get(message.params.requestId)?.abort();
+        return;
+      }
+      if (message.method?.startsWith("notifications/"))
+        return;
+      if (message.id === undefined || message.id === null)
+        return;
+      if (message.method === "initialize")
+        return respond({ protocolVersion: "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "vsl", version: package_default.version } });
+      if (message.method === "ping")
+        return respond({});
+      if (message.method === "tools/list")
+        return respond({ tools: tools.map((item) => ({ name: item.name, description: item.description, inputSchema: item.input })) });
+      if (message.method === "tools/call") {
+        const item = byName.get(message.params?.name ?? "");
+        if (!item)
+          return { jsonrpc: "2.0", id: message.id, error: { code: -32602, message: `unknown tool: ${message.params?.name}` } };
+        if (running.has(message.id))
+          return { jsonrpc: "2.0", id: message.id, error: { code: -32600, message: "duplicate active request ID" } };
+        const controller = new AbortController;
+        running.set(message.id, controller);
+        try {
+          const args = message.params?.arguments ?? {};
+          validateInput(item.input, args);
+          const directory = options.directory ?? process.cwd();
+          const output = await item.execute(args, { directory, worktree: directory, signal: controller.signal, report: () => {
+            return;
+          } });
+          return respond({ content: [{ type: "text", text: output.output }], isError: output.isError ?? false });
+        } catch (error) {
+          return respond({ content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true });
+        } finally {
+          running.delete(message.id);
+        }
+      }
+      return { jsonrpc: "2.0", id: message.id, error: { code: -32601, message: `unknown method: ${message.method}` } };
+    }
+  };
+}
+async function runMcpServer(input, write, protocol = createMcpProtocol()) {
+  const reader = input.getReader();
+  const decoder = new TextDecoder;
+  const pending = new Set;
+  let buffer = "";
+  const dispatch = (line) => {
+    if (!line.trim())
+      return;
+    if (line.length > 4 * 1024 * 1024)
+      throw new Error("MCP request exceeds 4 MiB");
+    const task = Promise.resolve().then(async () => {
+      const message = JSON.parse(line);
+      if (!message || typeof message !== "object" || Array.isArray(message) || !("method" in message) || typeof message.method !== "string" || !("jsonrpc" in message) || message.jsonrpc !== "2.0" || "id" in message && message.id !== null && typeof message.id !== "string" && typeof message.id !== "number" || "params" in message && (!message.params || typeof message.params !== "object" || Array.isArray(message.params))) {
+        write(`${JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32600, message: "Invalid Request" } })}
+`);
+        return;
+      }
+      const response = await protocol.handle(message);
+      if (response)
+        write(`${JSON.stringify(response)}
+`);
+    }).catch((error) => {
+      write(`${JSON.stringify({ jsonrpc: "2.0", id: null, error: {
+        code: error instanceof SyntaxError ? -32700 : -32603,
+        message: error instanceof SyntaxError ? "Parse error" : "Internal error"
+      } })}
+`);
+    });
+    pending.add(task);
+    task.then(() => pending.delete(task));
+  };
+  try {
+    for (;; ) {
+      const result = await reader.read();
+      if (result.done)
+        break;
+      buffer += decoder.decode(result.value, { stream: true });
+      for (;; ) {
+        const newline = buffer.indexOf(`
+`);
+        if (newline < 0)
+          break;
+        dispatch(buffer.slice(0, newline));
+        buffer = buffer.slice(newline + 1);
+      }
+      if (buffer.length > 4 * 1024 * 1024)
+        throw new Error("MCP request exceeds 4 MiB");
+    }
+    buffer += decoder.decode();
+    if (buffer.trim())
+      dispatch(buffer);
+    await Promise.resolve();
+  } finally {
+    protocol.abortAll();
+    await Promise.allSettled(pending);
+    reader.releaseLock();
+  }
+}
+if (import.meta.main)
+  await runMcpServer(Bun.stdin.stream(), (line) => {
+    process.stdout.write(line);
+  });
+export {
+  runMcpServer,
+  createMcpProtocol
+};