@bitfun-vsl/plugin 0.0.0-stage → 0.0.2

package/dist/hosts/deveco/plugin.js

@@ -0,0 +1,659 @@
+// @bun
+// src/hosts/deveco/plugin.ts
+import { resolve as resolve4 } from "path";
+
+// src/runtime.ts
+import { readFileSync, existsSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+// assets/build.json
+var build_default = {
+  version: "0.0.2",
+  buildId: "703e0faaffd4389a2ca0cadda8dc407ef83a1cf94e2469f1b73f13d2499afe7b"
+};
+
+// src/runtime.ts
+function packageRoot(url) {
+  const visit = (directory) => {
+    if (existsSync(join(directory, ".vsl-runtime.json")))
+      return directory;
+    const manifest = join(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(join(root, ".vsl-runtime.json")) ? join(root, ".vsl-runtime.json") : join(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: resolve(root),
+    installationId: runtimeConfig(root)?.installationId,
+    modules: modules.map((item) => ({ id: item.id, version: item.version }))
+  };
+}
+
+// src/hosts/shared/opencode.ts
+import { tool as tool2 } from "@opencode-ai/plugin";
+import { access as access2 } from "fs/promises";
+import { resolve as resolve3 } from "path";
+
+// 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 as join2, resolve as resolve2 } 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(resolve2(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) => join2(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 = join2(options.cacheDirectory ?? process.env.VSL_CR_CACHE_DIR ?? join2(process.env.LOCALAPPDATA ?? process.env.XDG_CACHE_HOME ?? join2(homedir(), ".cache"), "vsl", "cr"), crypto.randomUUID());
+  await mkdir(directory, { recursive: true, mode: 448 });
+  const resultFile = join2(directory, "result.json");
+  const stderrFile = join2(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 });
+}
+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/shared/schema.ts
+import { tool } from "@opencode-ai/plugin";
+function hostSchema(schema) {
+  if (schema.type === "object") {
+    const object = tool.schema.object(hostArgs(schema));
+    return schema.additionalProperties === false ? object.strict() : object;
+  }
+  if (schema.type === "array")
+    return tool.schema.array(hostSchema(schema.items ?? { type: "string" }));
+  if (schema.type === "boolean")
+    return tool.schema.boolean();
+  if (schema.type === "string") {
+    if (schema.enum?.length)
+      return tool.schema.enum(schema.enum);
+    return tool.schema.string();
+  }
+  const number = schema.type === "integer" ? tool.schema.number().int() : tool.schema.number();
+  if (schema.minimum !== undefined && schema.maximum !== undefined)
+    return number.min(schema.minimum).max(schema.maximum);
+  if (schema.minimum !== undefined)
+    return number.min(schema.minimum);
+  if (schema.maximum !== undefined)
+    return number.max(schema.maximum);
+  return number;
+}
+function hostArgs(schema) {
+  return Object.fromEntries(Object.entries(schema.properties ?? {}).map(([key, property]) => {
+    const value = hostSchema(property).describe(property.description ?? key);
+    return [key, schema.required?.includes(key) ? value : value.optional()];
+  }));
+}
+
+// src/hosts/shared/opencode.ts
+var wrapTool = (item, input) => tool2({
+  description: item.description,
+  args: hostArgs(item.input),
+  execute: async (args, context) => {
+    validateInput(item.input, args);
+    return item.execute(args, {
+      directory: context.directory || input.directory,
+      worktree: context.worktree || input.worktree,
+      signal: context.abort,
+      sessionId: context.sessionID,
+      report: (title) => context.metadata({ title })
+    });
+  }
+});
+var addStaticSkills = async (config, skillRoot, names) => {
+  const skillConfig = config;
+  const skills = skillConfig.skills ??= {};
+  const paths = skills.paths ??= [];
+  const directories = await Promise.all(names.map(async (name) => {
+    const directory = resolve3(skillRoot, name);
+    await access2(resolve3(directory, "SKILL.md"));
+    return directory;
+  }));
+  paths.push(...directories.filter((directory) => !paths.includes(directory)));
+};
+var createOpenCodeHost = (host) => async (input, options) => {
+  const resources = createHostRegistry(packageRoot(import.meta.url)).enabled();
+  const writeCommands = typeof options?.writeCommands === "boolean" ? options.writeCommands : host.writeCommands ?? true;
+  return {
+    async config(config) {
+      if (writeCommands) {
+        const commands = config.command ??= {};
+        resources.commands.forEach((command) => {
+          if (commands[command.name])
+            throw new Error(`command conflict: ${command.name}`);
+          commands[command.name] = {
+            template: command.template,
+            description: command.description,
+            agent: command.agent,
+            model: command.model,
+            subtask: command.subtask
+          };
+        });
+      }
+      const agents = config.agent ??= {};
+      resources.agents.forEach((agent) => {
+        if (agents[agent.name])
+          throw new Error(`agent conflict: ${agent.name}`);
+        agents[agent.name] = {
+          mode: agent.mode,
+          prompt: agent.prompt,
+          description: agent.description,
+          model: agent.model,
+          hidden: agent.hidden,
+          permission: agent.permission
+        };
+      });
+      await addStaticSkills(config, host.skillRoot, resources.skills.map((skill) => skill.name));
+    },
+    tool: Object.fromEntries(resources.tools.map((item) => [item.name, wrapTool(item, input)]))
+  };
+};
+
+// src/hosts/deveco/plugin.ts
+var skillRoot = resolve4(packageRoot(import.meta.url), "assets/skills");
+var VslPlugin = createOpenCodeHost({ skillRoot, writeCommands: true });
+var plugin_default = VslPlugin;
+export {
+  plugin_default as default,
+  VslPlugin
+};

package/dist/hosts/shared/opencode.d.ts

@@ -0,0 +1,12 @@
+import { type Hooks, type PluginInput, type PluginOptions } from "@opencode-ai/plugin";
+export type OpenCodeHostOptions = {
+    /** Absolute directory holding one `<name>/SKILL.md` subtree per skill. */
+    skillRoot: string;
+    /**
+     * DevEco and OpenCode project `config.command` into slash commands. BitFun's
+     * plugin projection ignores that key, and a same-named host command makes the
+     * whole `config` hook fail, so the BitFun entry turns it off.
+     */
+    writeCommands?: boolean;
+};
+export declare const createOpenCodeHost: (host: OpenCodeHostOptions) => (input: PluginInput, options?: PluginOptions | undefined) => Promise<Hooks>;

package/dist/hosts/shared/schema.d.ts

@@ -0,0 +1,8 @@
+import { tool } from "@opencode-ai/plugin";
+import type { JsonSchema } from "../../plugin/contracts.js";
+type HostSchema = InstanceType<typeof tool.schema.ZodType>;
+export declare function hostSchema(schema: JsonSchema): HostSchema;
+export declare function hostArgs(schema: JsonSchema): {
+    [k: string]: import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+};
+export {};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { VslPlugin as default, VslPlugin } from "./hosts/deveco/plugin.js";
+export * from "./plugin/index.js";