@bitfun-vsl/plugin 0.0.0-stage → 0.0.1

package/dist/install/resources.js

@@ -0,0 +1,590 @@
+// @bun
+// src/install/resources.ts
+import { join as join2, resolve as resolve2, relative, isAbsolute as isAbsolute2, dirname } from "path";
+import { mkdir as mkdir2, readdir } from "fs/promises";
+
+// 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/plugin/index.ts
+function createRegistry(input = {}) {
+  return createModuleRegistry({ modules: input.modules ?? [createTrajectoryAnalysisModule(), createCodeReviewModule({ binary: input.crBinary })], enabled: input.enabled });
+}
+
+// src/hosts/bitfun-kernel/commands.ts
+var bitfunCommandPath = (name) => `${name.replaceAll(":", "/")}.md`;
+var bitfunCommandFile = (command, includeAgent = false) => {
+  const frontMatter = [`description: ${JSON.stringify(command.description)}`];
+  if (includeAgent && command.agent)
+    frontMatter.push(`agent: ${JSON.stringify(command.agent)}`);
+  if (command.model)
+    frontMatter.push(`model: ${JSON.stringify(command.model)}`);
+  if (command.subtask !== undefined)
+    frontMatter.push(`subtask: ${command.subtask}`);
+  return `---
+${frontMatter.join(`
+`)}
+---
+
+${command.template.trim()}
+`;
+};
+if (false) {}
+
+// src/install/resources.ts
+var digest = (content) => new Bun.CryptoHasher("sha256").update(content).digest("hex");
+function inside(root, path) {
+  const target = resolve2(root, path);
+  const part = relative(resolve2(root), target);
+  if (part === ".." || part.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute2(part))
+    throw new Error(`Path escapes VSL root: ${path}`);
+  return target;
+}
+async function filesUnder(root) {
+  return (await Promise.all((await readdir(root, { withFileTypes: true })).map(async (entry) => {
+    if (entry.isSymbolicLink())
+      throw new Error(`Symlink not allowed in managed resources: ${join2(root, entry.name)}`);
+    if (entry.isDirectory())
+      return (await filesUnder(join2(root, entry.name))).map((file) => `${entry.name}/${file}`);
+    return entry.isFile() ? [entry.name] : [];
+  }))).flat().sort();
+}
+function selectResources(names) {
+  const all = createRegistry().enabled();
+  const unknown = names?.find((name) => !all.modules.some((module) => module.id === name));
+  if (unknown)
+    throw new Error(`Unknown VSL module: ${unknown}`);
+  if (names && new Set(names).size !== names.length)
+    throw new Error("Duplicate VSL module selection");
+  return createRegistry({ modules: all.modules.filter((module) => !names || names.includes(module.id)) }).enabled();
+}
+function renderResources(resources, version) {
+  const invalid = [...resources.commands.map((item) => item.name.replace(/^vsl:/, "")), ...resources.agents.map((item) => item.name), ...resources.skills.map((item) => item.name)].find((name) => !/^[a-z0-9][a-z0-9-]*$/.test(name));
+  if (invalid)
+    throw new Error(`Resource name cannot be mapped to host files: ${invalid}`);
+  const unsupported = resources.agents.find((agent) => agent.permission && Object.keys(agent.permission).length || agent.hidden || agent.mode !== "subagent");
+  if (unsupported)
+    throw new Error(`Claude resource generation requires an explicit adapter for agent permissions, visibility or mode: ${unsupported.name}`);
+  const frontmatter = (values) => `---
+${Object.entries(values).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(`
+`)}
+---
+
+`;
+  return {
+    "claude-code/.claude-plugin/plugin.json": `${JSON.stringify({ name: "vsl", version, description: "VSL shared modules and tools" }, null, 2)}
+`,
+    "claude-code/.mcp.json": `${JSON.stringify({ mcpServers: { vsl: { command: "bun", args: ["${CLAUDE_PLUGIN_ROOT}/scripts/mcp-server.js"] } } }, null, 2)}
+`,
+    ...Object.fromEntries(resources.commands.map((command) => [
+      `claude-code/commands/${command.name.replace(/^vsl:/, "")}.md`,
+      `${frontmatter({ description: command.description, ...command.model ? { model: command.model } : {} })}Use the VSL MCP tools with their registered host prefix. Pass the absolute current project as repo when applicable.
+
+${command.template}
+`
+    ])),
+    ...Object.fromEntries(resources.agents.map((agent) => [
+      `claude-code/agents/${agent.name}.md`,
+      `${frontmatter({ name: agent.name, description: agent.description ?? agent.name, ...agent.model ? { model: agent.model } : {} })}${agent.prompt}
+`
+    ])),
+    ...Object.fromEntries(resources.commands.map((command) => [`bitfun/command/${bitfunCommandPath(command.name)}`, bitfunCommandFile(command)])),
+    ...Object.fromEntries(["deveco", "claude-code", "shared"].flatMap((host) => resources.skills.flatMap((skill) => [
+      [`${host === "shared" ? "" : host + "/"}skills/${skill.name}/SKILL.md`, `${frontmatter({ name: skill.name, description: skill.description })}${skill.content}
+`],
+      ...Object.entries(skill.files ?? {}).map(([path, content]) => {
+        inside(resolve2("/vsl-resource", skill.name), path);
+        return [`${host === "shared" ? "" : host + "/"}skills/${skill.name}/${path}`, content];
+      })
+    ])))
+  };
+}
+async function writeResources(root, resources) {
+  await Promise.all(Object.entries(resources).map(async ([path, content]) => {
+    const target = inside(root, path);
+    await mkdir2(dirname(target), { recursive: true });
+    await Bun.write(target, content);
+  }));
+}
+export {
+  writeResources,
+  selectResources,
+  renderResources,
+  inside,
+  filesUnder,
+  digest
+};

package/dist/plugin/contracts.d.ts

@@ -0,0 +1,63 @@
+export type JsonSchema = {
+    type: "object" | "string" | "boolean" | "number" | "integer" | "array";
+    description?: string;
+    properties?: Record<string, JsonSchema>;
+    items?: JsonSchema;
+    enum?: string[];
+    minimum?: number;
+    maximum?: number;
+    required?: string[];
+    additionalProperties?: boolean;
+};
+export type ModuleContext = {
+    directory: string;
+    worktree: string;
+    signal: AbortSignal;
+    sessionId?: string;
+    report(title: string): void;
+};
+export type ToolOutput = {
+    title: string;
+    output: string;
+    metadata?: Record<string, unknown>;
+    isError?: boolean;
+};
+export type ModuleTool = {
+    name: string;
+    description: string;
+    input: JsonSchema;
+    execute(input: unknown, context: ModuleContext): Promise<ToolOutput>;
+};
+export type ModuleCommand = {
+    name: string;
+    description: string;
+    template: string;
+    agent?: string;
+    model?: string;
+    subtask?: boolean;
+    toolNames?: string[];
+};
+export type ModuleAgent = {
+    name: string;
+    description?: string;
+    mode: "primary" | "subagent" | "all";
+    prompt: string;
+    model?: string;
+    permission?: Record<string, "allow" | "ask" | "deny">;
+    hidden?: boolean;
+};
+export type ModuleSkill = {
+    name: string;
+    description: string;
+    content: string;
+    files?: Record<string, string | Uint8Array>;
+};
+export type PluginModule = {
+    id: string;
+    version: string;
+    description: string;
+    commands?: ModuleCommand[];
+    agents?: ModuleAgent[];
+    skills?: ModuleSkill[];
+    tools?: ModuleTool[];
+};

package/dist/plugin/index.d.ts

@@ -0,0 +1,19 @@
+import type { PluginModule } from "./contracts.js";
+export * from "./contracts.js";
+export { createModuleRegistry } from "./registry.js";
+export { createTrajectoryAnalysisModule } from "./modules/trajectory-analysis.js";
+export { createCodeReviewModule } from "./modules/code-review/index.js";
+export declare function createRegistry(input?: {
+    modules?: PluginModule[];
+    enabled?: Record<string, boolean>;
+    crBinary?: string;
+}): {
+    enabled: () => import("./registry.js").PluginResources;
+    command: (name: string) => import("./contracts.js").ModuleCommand | undefined;
+    tool: (name: string) => import("./contracts.js").ModuleTool | undefined;
+};
+export declare function createHostRegistry(root: string): {
+    enabled: () => import("./registry.js").PluginResources;
+    command: (name: string) => import("./contracts.js").ModuleCommand | undefined;
+    tool: (name: string) => import("./contracts.js").ModuleTool | undefined;
+};