@vaubaan/harness 0.0.0-stage → 1.3.2

package/dist/init.js

@@ -0,0 +1,1088 @@
+// src/cli/init.ts
+import { existsSync as existsSync6, mkdirSync, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3, join as join7, resolve as resolve3 } from "path";
+import { fileURLToPath } from "url";
+
+// src/loader.ts
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { join } from "path";
+import fg from "fast-glob";
+import { z as z2 } from "zod";
+
+// src/parser/common.ts
+import { readFileSync } from "fs";
+import matter from "gray-matter";
+
+// src/parser/schemas.ts
+import { z } from "zod";
+
+// src/types.ts
+var AGENT_IDS = ["coding", "review", "merge", "planning"];
+var ENGINES = ["claude-code", "codex-cli", "opencode"];
+var CAPABILITIES = ["multi-step", "slash-command", "inline-exec"];
+var CAPABILITIES_MATRIX = {
+  "claude-code": ["multi-step", "slash-command", "inline-exec"],
+  "codex-cli": ["multi-step", "slash-command", "inline-exec"],
+  opencode: ["multi-step", "slash-command", "inline-exec"]
+};
+var DEGRADED_CAPABILITIES = {
+  "codex-cli": ["multi-step"]
+};
+
+// src/parser/schemas.ts
+var IdSchema = z.string().min(1).regex(/^[a-z][a-z0-9-]*$/, "id must be kebab-case (lowercase + digits + hyphens)");
+var SkillFrontmatterSchema = z.object({
+  id: IdSchema,
+  description: z.string().min(1),
+  engines: z.array(z.enum(ENGINES)).min(1).optional(),
+  requires: z.array(z.enum(CAPABILITIES)).optional(),
+  tags: z.array(z.string()).optional()
+}).strict();
+var CmdArgEnumSchema = z.object({
+  name: z.string().min(1),
+  type: z.literal("enum"),
+  values: z.array(z.string()).min(1),
+  default: z.string().optional()
+}).strict();
+var CmdArgStringSchema = z.object({
+  name: z.string().min(1),
+  type: z.literal("string"),
+  default: z.string().optional()
+}).strict();
+var CmdArgSchema = z.discriminatedUnion("type", [CmdArgEnumSchema, CmdArgStringSchema]);
+var CmdFrontmatterSchema = z.object({
+  id: IdSchema,
+  trigger: z.string().regex(/^\/[a-z][a-z0-9-]*$/, "trigger must be /kebab-case"),
+  invokes_skill: IdSchema,
+  args: z.array(CmdArgSchema).optional(),
+  description: z.string().min(1)
+}).strict();
+var AgentFrontmatterSchema = z.object({
+  id: z.enum(AGENT_IDS),
+  description: z.string().min(1)
+}).strict();
+var Schemas = {
+  Skill: SkillFrontmatterSchema,
+  Cmd: CmdFrontmatterSchema,
+  Agent: AgentFrontmatterSchema
+};
+var ParseError = class extends Error {
+  constructor(file, issues) {
+    const messages = issues.map((i) => `  - ${i.path.join(".") || "<root>"}: ${i.message}`).join("\n");
+    super(`Frontmatter validation failed for ${file}:
+${messages}`);
+    this.file = file;
+    this.issues = issues;
+    this.name = "ParseError";
+  }
+  file;
+  issues;
+};
+
+// src/parser/common.ts
+function parseWithSchema(filePath, source, schema) {
+  const parsed = matter(source);
+  const result = schema.safeParse(parsed.data);
+  if (!result.success) {
+    throw new ParseError(filePath, result.error.issues);
+  }
+  return {
+    meta: result.data,
+    body: parsed.content.trim(),
+    sourcePath: filePath
+  };
+}
+
+// src/parser/agent.ts
+function parseAgent(filePath, source) {
+  return parseWithSchema(filePath, source, Schemas.Agent);
+}
+
+// src/parser/cmd.ts
+function parseCmd(filePath, source) {
+  return parseWithSchema(filePath, source, Schemas.Cmd);
+}
+
+// src/parser/skill.ts
+function parseSkill(filePath, source) {
+  return parseWithSchema(filePath, source, Schemas.Skill);
+}
+
+// src/util/yaml.ts
+import { parse as yamlParse } from "yaml";
+function parseYAML(source) {
+  return yamlParse(source);
+}
+
+// src/loader.ts
+var DisableYamlSchema = z2.object({ disable: z2.array(z2.string()).optional() }).passthrough();
+function loadHarness(packageDir, opts = {}) {
+  const agentsDir = opts.agentsDir ?? join(packageDir, "agents");
+  const skillsDir = opts.skillsDir ?? join(packageDir, "skills");
+  const commandsDir = opts.commandsDir ?? join(packageDir, "commands");
+  const agentFiles = fg.sync("*.agent.md", { cwd: agentsDir, absolute: true });
+  const skillFiles = fg.sync("*.skill.md", { cwd: skillsDir, absolute: true });
+  const cmdFiles = fg.sync("*.cmd.md", { cwd: commandsDir, absolute: true });
+  return {
+    agents: agentFiles.map((f) => parseAgent(f, readFileSync2(f, "utf8"))),
+    skills: skillFiles.map((f) => parseSkill(f, readFileSync2(f, "utf8"))),
+    cmds: cmdFiles.map((f) => parseCmd(f, readFileSync2(f, "utf8")))
+  };
+}
+function loadProjectSkills(targetDir) {
+  const skillsDir = join(targetDir, "docs", "skills");
+  if (!existsSync(skillsDir)) return [];
+  const skillFiles = fg.sync("*.skill.md", { cwd: skillsDir, absolute: true });
+  return skillFiles.map((f) => parseSkill(f, readFileSync2(f, "utf8")));
+}
+function loadOverrides(worktreeDir) {
+  const overridesDir = join(worktreeDir, ".harness-overrides");
+  if (!existsSync(overridesDir)) return void 0;
+  const added = loadHarness(overridesDir, {
+    agentsDir: join(overridesDir, "agents"),
+    skillsDir: join(overridesDir, "skills"),
+    commandsDir: join(overridesDir, "commands")
+  });
+  const disablePath = join(overridesDir, "disable.yaml");
+  let disable = [];
+  if (existsSync(disablePath)) {
+    try {
+      const parsed = DisableYamlSchema.safeParse(parseYAML(readFileSync2(disablePath, "utf8")));
+      if (parsed.success && parsed.data.disable) {
+        disable = parsed.data.disable;
+      }
+    } catch {
+    }
+  }
+  return { add: added, disable };
+}
+
+// src/mcp.ts
+var MCP_SERVER_IDS = ["context7"];
+var MCP_SERVERS = {
+  context7: {
+    id: "context7",
+    description: "Upstash Context7 \u2014 fetches up-to-date library docs via resolve-library-id + get-library-docs.",
+    command: "npx",
+    args: ["-y", "@upstash/context7-mcp"]
+  }
+};
+function resolveMcpIds(requested) {
+  return requested.map((id) => {
+    if (!MCP_SERVER_IDS.includes(id)) {
+      throw new Error(`unknown MCP server: ${id} (expected one of ${MCP_SERVER_IDS.join(", ")})`);
+    }
+    return id;
+  });
+}
+
+// src/renderers/common.ts
+import { stringify as yamlStringify } from "yaml";
+var STOP_HOOK_PACKAGE = "@vaubaan/harness";
+function checkSkillCapabilities(skill, engine) {
+  const blockingWarnings = [];
+  const degradedWarnings = [];
+  const supported = CAPABILITIES_MATRIX[engine];
+  const degraded = DEGRADED_CAPABILITIES[engine] ?? [];
+  if (!skill.meta.requires) return { blockingWarnings, degradedWarnings };
+  for (const cap of skill.meta.requires) {
+    if (!supported.includes(cap)) {
+      blockingWarnings.push(
+        `skill "${skill.meta.id}" requires "${cap}" not supported by "${engine}" \u2014 skipped`
+      );
+    } else if (degraded.includes(cap)) {
+      degradedWarnings.push(
+        `skill "${skill.meta.id}" requires "${cap}" \u2014 supported by "${engine}" with degradation`
+      );
+    }
+  }
+  return { blockingWarnings, degradedWarnings };
+}
+function isSkillEngineAllowed(skill, engine) {
+  if (!skill.meta.engines) return true;
+  return skill.meta.engines.includes(engine);
+}
+function yamlFrontmatter(data) {
+  const rendered = yamlStringify(data, { lineWidth: 0 }).trimEnd();
+  return `---
+${rendered}
+---
+`;
+}
+var SCALAR_NEEDS_QUOTE = /[^a-zA-Z0-9_./-]/;
+function tomlEscapeString(s) {
+  return `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
+}
+function tomlValue(v) {
+  if (Array.isArray(v)) {
+    return `[${v.map((x) => tomlValue(x)).join(", ")}]`;
+  }
+  if (typeof v === "string") {
+    if (v.includes("\n")) return tomlEscapeString(v);
+    return SCALAR_NEEDS_QUOTE.test(v) ? tomlEscapeString(v) : `"${v}"`;
+  }
+  if (typeof v === "boolean" || typeof v === "number") {
+    return String(v);
+  }
+  return tomlEscapeString(String(v));
+}
+function tomlMultilineString(s) {
+  const escaped = s.replace(/\\/g, "\\\\").replace(/"""/g, '""\\"');
+  return `"""
+${escaped}
+"""`;
+}
+function tomlQuoteString(s) {
+  return tomlValue(s);
+}
+function tomlInlineArray(items) {
+  return tomlValue([...items]);
+}
+function tomlInlineTable(table) {
+  const entries = Object.entries(table).map(([k, v]) => `${k} = ${tomlValue(v)}`);
+  return `{ ${entries.join(", ")} }`;
+}
+function frontmatterDataForSkill(skill) {
+  const data = {
+    name: skill.meta.id,
+    description: skill.meta.description
+  };
+  if (skill.meta.tags && skill.meta.tags.length > 0) data.tags = skill.meta.tags;
+  return data;
+}
+function frontmatterDataForCmd(cmd) {
+  const data = {
+    id: cmd.meta.id,
+    trigger: cmd.meta.trigger,
+    description: cmd.meta.description
+  };
+  if (cmd.meta.args && cmd.meta.args.length > 0) {
+    data.args = cmd.meta.args.map((a) => {
+      if (a.type === "enum") {
+        return a.default !== void 0 ? { name: a.name, type: a.type, values: a.values, default: a.default } : { name: a.name, type: a.type, values: a.values };
+      }
+      return a.default !== void 0 ? { name: a.name, type: a.type, default: a.default } : { name: a.name, type: a.type };
+    });
+  }
+  return data;
+}
+function buildAgentBody(agent) {
+  return `${agent.body.trim()}
+`;
+}
+function buildUmbrellaBody(_agents, extras) {
+  const triggerBySkill = new Map(
+    extras.availableCommands.map((c) => [c.meta.invokes_skill, c.meta.trigger])
+  );
+  const skillLines = extras.availableSkills.map((s) => {
+    const trigger = triggerBySkill.get(s.meta.id);
+    const label = trigger ? `\`${s.meta.id}\` (\`${trigger}\`)` : `\`${s.meta.id}\``;
+    return `- ${label} \u2014 ${s.meta.description.split("\n")[0]}`;
+  });
+  const sections = [
+    "# How we work",
+    "",
+    "This file describes **how to work in this project**. The **business context** (what the project does, how to run it, which subsystems it contains) lives in `README.md` and `docs/`. Read them first.",
+    "",
+    "## Project map",
+    "",
+    "- `README.md` \u2014 pitch, quick start, scripts. Entry point.",
+    "- `docs/spec/<subsystem>.md` \u2014 *what* and *why* (tech-agnostic).",
+    "- `docs/handbook/<feature>.md` \u2014 *how it actually works* today.",
+    "- `docs/decisions/<slug>.md` \u2014 ADRs: structural choices and rejected alternatives.",
+    "- `docs/tests/integration-tests.md` & `e2e-tests.md` \u2014 core scenarios.",
+    "- `docs/workflow/coding-workflow.md` \u2014 CI, branches, PR, release.",
+    ...extras.hasProjectSkills ? ["- `docs/skills/*.skill.md` \u2014 the project's domain skills."] : [],
+    ...extras.hasQualityDoc ? [
+      "- `docs/quality/code-quality.md` \u2014 the project's code-quality rules: mechanical checks, judgment rules, accepted deviations. Read it before writing or auditing code."
+    ] : [],
+    "",
+    "## Doc-first",
+    "",
+    "The order is: **understand the docs \u2192 fill the gaps \u2192 code \u2192 update the docs \u2192 commit**. If the docs are silent or stale on something you change, fill the gap upfront with the doc-skill writers \u2014 not downstream, not after the fact.",
+    "",
+    "- Missing spec for a subsystem you touch \u2192 **do not code**, report the gap.",
+    "- Implicit structural decision in your changes \u2192 an ADR (`/decision`).",
+    "- Changed feature behavior \u2192 update the matching handbook (`/handbook`).",
+    "- Suspected code \u2194 doc drift \u2192 `/drift` before moving on."
+  ];
+  if (skillLines.length > 0) {
+    sections.push("", "## Doc-skills", "", skillLines.join("\n"));
+  }
+  return `${sections.join("\n")}
+`;
+}
+
+// src/renderers/claude-code.ts
+var ENGINE = "claude-code";
+var BASE = ".claude";
+var claudeCodeRenderer = {
+  engine: ENGINE,
+  renderSkill(skill) {
+    if (!isSkillEngineAllowed(skill, ENGINE)) {
+      return {
+        files: [],
+        warnings: [`skill "${skill.meta.id}" excluded from engine "${ENGINE}"`]
+      };
+    }
+    const check = checkSkillCapabilities(skill, ENGINE);
+    if (check.blockingWarnings.length > 0) {
+      return { files: [], warnings: check.blockingWarnings };
+    }
+    const content = `${yamlFrontmatter(frontmatterDataForSkill(skill))}
+${skill.body}
+`;
+    return {
+      files: [{ path: `${BASE}/skills/${skill.meta.id}/SKILL.md`, content }],
+      warnings: check.degradedWarnings
+    };
+  },
+  renderCmd(cmd) {
+    const content = `${yamlFrontmatter(frontmatterDataForCmd(cmd))}
+${cmd.body}
+`;
+    return {
+      files: [{ path: `${BASE}/commands/${cmd.meta.id}.md`, content }],
+      warnings: []
+    };
+  },
+  renderAgents(agents) {
+    const files = [];
+    for (const agent of agents) {
+      const subagentFrontmatter = yamlFrontmatter({
+        name: agent.meta.id,
+        description: agent.meta.description
+      });
+      const body = buildAgentBody(agent);
+      const content = `${subagentFrontmatter}
+${body}`;
+      files.push({ path: `${BASE}/agents/${agent.meta.id}.md`, content });
+    }
+    return { files, warnings: [] };
+  },
+  renderMcp(servers) {
+    if (servers.length === 0) return { files: [], warnings: [] };
+    const mcpServers = {};
+    for (const s of servers) {
+      const entry = { command: s.command, args: [...s.args] };
+      if (s.env) entry.env = s.env;
+      mcpServers[s.id] = entry;
+    }
+    const content = `${JSON.stringify({ mcpServers }, null, 2)}
+`;
+    return { files: [{ path: ".mcp.json", content }], warnings: [] };
+  },
+  renderStopHook() {
+    const settings = {
+      hooks: {
+        Stop: [
+          {
+            matcher: "",
+            hooks: [
+              {
+                type: "command",
+                command: `npx -y ${STOP_HOOK_PACKAGE} stop-hook --engine claude`
+              }
+            ]
+          }
+        ]
+      }
+    };
+    return {
+      files: [{ path: `${BASE}/settings.json`, content: `${JSON.stringify(settings, null, 2)}
+` }],
+      warnings: []
+    };
+  }
+};
+
+// src/renderers/codex-cli.ts
+var ENGINE2 = "codex-cli";
+var BASE2 = ".codex";
+var SKILLS_BASE = ".agents/skills";
+var codexCliRenderer = {
+  engine: ENGINE2,
+  renderSkill(skill) {
+    if (!isSkillEngineAllowed(skill, ENGINE2)) {
+      return {
+        files: [],
+        warnings: [`skill "${skill.meta.id}" excluded from engine "${ENGINE2}"`]
+      };
+    }
+    const check = checkSkillCapabilities(skill, ENGINE2);
+    if (check.blockingWarnings.length > 0) {
+      return { files: [], warnings: check.blockingWarnings };
+    }
+    const content = `${yamlFrontmatter(frontmatterDataForSkill(skill))}
+${skill.body}
+`;
+    return {
+      files: [{ path: `${SKILLS_BASE}/${skill.meta.id}/SKILL.md`, content }],
+      warnings: check.degradedWarnings
+    };
+  },
+  // Codex custom prompts are deprecated in favour of skills: nothing to render.
+  renderCmd(_cmd) {
+    return { files: [], warnings: [] };
+  },
+  renderAgents(agents) {
+    const files = [];
+    for (const agent of agents) {
+      const content = [
+        `name = ${tomlQuoteString(agent.meta.id)}`,
+        `description = ${tomlQuoteString(agent.meta.description)}`,
+        `developer_instructions = ${tomlMultilineString(buildAgentBody(agent).trimEnd())}`,
+        ""
+      ].join("\n");
+      files.push({ path: `${BASE2}/agents/${agent.meta.id}.toml`, content });
+    }
+    return { files, warnings: [] };
+  },
+  renderMcp(servers) {
+    if (servers.length === 0) return { files: [], warnings: [] };
+    const blocks = [];
+    for (const s of servers) {
+      const lines = [
+        `[mcp_servers.${s.id}]`,
+        `command = ${tomlQuoteString(s.command)}`,
+        `args = ${tomlInlineArray([...s.args])}`
+      ];
+      if (s.env) lines.push(`env = ${tomlInlineTable(s.env)}`);
+      blocks.push(lines.join("\n"));
+    }
+    const content = `${blocks.join("\n\n")}
+`;
+    return { files: [{ path: `${BASE2}/config.toml`, content }], warnings: [] };
+  },
+  renderStopHook() {
+    const hooks = {
+      hooks: {
+        Stop: [
+          {
+            hooks: [
+              {
+                type: "command",
+                command: `npx -y ${STOP_HOOK_PACKAGE} stop-hook --engine codex`
+              }
+            ]
+          }
+        ]
+      }
+    };
+    return {
+      files: [{ path: `${BASE2}/hooks.json`, content: `${JSON.stringify(hooks, null, 2)}
+` }],
+      warnings: []
+    };
+  }
+};
+
+// src/renderers/opencode.ts
+var ENGINE3 = "opencode";
+var BASE3 = ".opencode";
+var opencodeRenderer = {
+  engine: ENGINE3,
+  renderSkill(skill) {
+    if (!isSkillEngineAllowed(skill, ENGINE3)) {
+      return {
+        files: [],
+        warnings: [`skill "${skill.meta.id}" excluded from engine "${ENGINE3}"`]
+      };
+    }
+    const check = checkSkillCapabilities(skill, ENGINE3);
+    if (check.blockingWarnings.length > 0) {
+      return { files: [], warnings: check.blockingWarnings };
+    }
+    const content = `${yamlFrontmatter(frontmatterDataForSkill(skill))}
+${skill.body}
+`;
+    return {
+      files: [{ path: `${BASE3}/skills/${skill.meta.id}/SKILL.md`, content }],
+      warnings: check.degradedWarnings
+    };
+  },
+  renderCmd(cmd) {
+    const content = `${yamlFrontmatter({ description: cmd.meta.description })}
+${cmd.body}
+`;
+    return {
+      files: [{ path: `${BASE3}/commands/${cmd.meta.id}.md`, content }],
+      warnings: []
+    };
+  },
+  renderAgents(agents) {
+    const files = [];
+    for (const agent of agents) {
+      const fm = yamlFrontmatter({
+        description: agent.meta.description,
+        mode: "all"
+      });
+      const body = buildAgentBody(agent);
+      files.push({ path: `${BASE3}/agents/${agent.meta.id}.md`, content: `${fm}
+${body}` });
+    }
+    return { files, warnings: [] };
+  },
+  renderMcp(servers) {
+    if (servers.length === 0) return { files: [], warnings: [] };
+    const mcp = {};
+    for (const s of servers) {
+      const entry = {
+        type: "local",
+        command: [s.command, ...s.args],
+        enabled: true
+      };
+      if (s.env) entry.environment = s.env;
+      mcp[s.id] = entry;
+    }
+    const config = { $schema: "https://opencode.ai/config.json", mcp };
+    const content = `${JSON.stringify(config, null, 2)}
+`;
+    return { files: [{ path: `${BASE3}/opencode.json`, content }], warnings: [] };
+  },
+  renderStopHook() {
+    const content = `import { spawnSync } from "node:child_process";
+
+// Runs the harness lint and returns the report to inject, or "" when the
+// turn may end.
+const lintReport = (directory, sessionID) => {
+  const r = spawnSync(
+    "npx",
+    ["-y", "${STOP_HOOK_PACKAGE}", "stop-hook", "--engine", "opencode", "--cwd", directory],
+    { input: JSON.stringify({ sessionID }), encoding: "utf-8" },
+  );
+  const report = (r.stderr ?? "").trim();
+  return r.status === 2 ? report : "";
+};
+
+// OpenCode 1.x entry point, exposed as server() below.
+const HarnessStopHook = async ({ client, directory }) => ({
+  event: async ({ event }) => {
+    if (event.type !== "session.idle") return;
+    const sessionID = event.properties?.sessionID;
+    if (!sessionID) return;
+    const report = lintReport(directory, sessionID);
+    if (report === "") return;
+    // OpenCode defaults to its build agent when a prompt omits agent.
+    // Preserve the last conversation persona, excluding compaction summaries.
+    const history = await client.session.messages({ path: { id: sessionID } }).catch(() => undefined);
+    if (history?.error || !Array.isArray(history?.data)) return;
+    const current = history.data.findLast(({ info }) =>
+      (info.role === "user" || (info.role === "assistant" && !info.summary)) &&
+      typeof info.agent === "string" && info.agent.trim() !== "",
+    );
+    if (!current) return;
+    await client.session.prompt({
+      path: { id: sessionID },
+      body: { agent: current.info.agent, parts: [{ type: "text", text: report }] },
+    });
+  },
+});
+
+// One default export for both majors: OpenCode 1.x calls server(),
+// OpenCode 2.x calls setup(). A V2 session keeps its agent, so the report
+// is sent without naming the persona.
+export default {
+  id: "vaubaan-harness-stop-hook",
+  server: HarnessStopHook,
+  setup(context) {
+    const directory = context.location.directory;
+    const controller = new AbortController();
+    const listen = async () => {
+      for await (const event of context.event.subscribe({ signal: controller.signal })) {
+        if (event.type !== "session.idle") continue;
+        if (event.location?.directory && event.location.directory !== directory) continue;
+        const sessionID = event.data?.sessionID;
+        if (!sessionID) continue;
+        const report = lintReport(directory, sessionID);
+        if (report === "") continue;
+        await context.session.prompt({ sessionID, text: report }).catch(() => undefined);
+      }
+    };
+    listen().catch(() => undefined);
+    return () => controller.abort();
+  },
+};
+`;
+    return {
+      files: [{ path: `${BASE3}/plugins/harness-stop-hook.ts`, content }],
+      warnings: []
+    };
+  }
+};
+
+// src/renderers/index.ts
+var RENDERERS = {
+  "claude-code": claudeCodeRenderer,
+  "codex-cli": codexCliRenderer,
+  opencode: opencodeRenderer
+};
+function getRenderer(engine) {
+  return RENDERERS[engine];
+}
+
+// src/render.ts
+var RenderError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RenderError";
+  }
+};
+function mergeById(stock, added) {
+  const result = /* @__PURE__ */ new Map();
+  for (const item of stock) result.set(item.meta.id, item);
+  if (added) {
+    for (const item of added) result.set(item.meta.id, item);
+  }
+  return Array.from(result.values());
+}
+function removeByIds(items, disabled) {
+  if (disabled.length === 0) return [...items];
+  const disabledSet = new Set(disabled);
+  return items.filter((item) => !disabledSet.has(item.meta.id));
+}
+function applyOverrides(harness, overrides) {
+  const disabled = overrides?.disable ?? [];
+  return {
+    agents: removeByIds(mergeById(harness.agents, overrides?.add?.agents), disabled),
+    skills: removeByIds(mergeById(harness.skills, overrides?.add?.skills), disabled),
+    cmds: removeByIds(mergeById(harness.cmds, overrides?.add?.cmds), disabled)
+  };
+}
+var CLAUDE_MD_STUB = "@AGENTS.md\n";
+function opencodeLast(engines) {
+  return [...engines].sort((a, b) => Number(a === "opencode") - Number(b === "opencode"));
+}
+function render(input) {
+  const { engines } = input;
+  if (engines.length === 0) {
+    throw new RenderError("at least one engine must be selected");
+  }
+  const base = input.projectSkills?.length ? { ...input.harness, skills: mergeById(input.harness.skills, input.projectSkills) } : input.harness;
+  const harness = applyOverrides(base, input.overrides);
+  if (harness.agents.length === 0) {
+    throw new RenderError("No agents found in harness");
+  }
+  const files = [];
+  const warnings = [];
+  const exposedSkills = /* @__PURE__ */ new Map();
+  const exposedCmds = /* @__PURE__ */ new Map();
+  for (const engine of opencodeLast(engines)) {
+    const renderer = getRenderer(engine);
+    const renderedSkills = [];
+    for (const skill of harness.skills) {
+      const result = renderer.renderSkill(skill);
+      warnings.push(...result.warnings);
+      if (result.files.length > 0) {
+        const alreadyVisible = engine === "opencode" && exposedSkills.has(skill.meta.id);
+        if (!alreadyVisible) files.push(...result.files);
+        renderedSkills.push(skill);
+        exposedSkills.set(skill.meta.id, skill);
+      }
+    }
+    const renderedSkillIds = new Set(renderedSkills.map((s) => s.meta.id));
+    const renderedCmds = [];
+    for (const cmd of harness.cmds) {
+      if (!renderedSkillIds.has(cmd.meta.invokes_skill)) continue;
+      const result = renderer.renderCmd(cmd);
+      warnings.push(...result.warnings);
+      if (result.files.length > 0) {
+        files.push(...result.files);
+        renderedCmds.push(cmd);
+        exposedCmds.set(cmd.meta.id, cmd);
+      }
+    }
+    const agentsResult = renderer.renderAgents(harness.agents);
+    warnings.push(...agentsResult.warnings);
+    files.push(...agentsResult.files);
+    if (input.mcpServers && input.mcpServers.length > 0) {
+      const specs = input.mcpServers.map((id) => MCP_SERVERS[id]);
+      const mcpResult = renderer.renderMcp(specs);
+      warnings.push(...mcpResult.warnings);
+      files.push(...mcpResult.files);
+    }
+    if (input.withStopHook !== false) {
+      const hookResult = renderer.renderStopHook();
+      warnings.push(...hookResult.warnings);
+      files.push(...hookResult.files);
+    }
+  }
+  const hasProjectSkills = (input.projectSkills?.length ?? 0) > 0;
+  const umbrellaContent = buildUmbrellaBody(harness.agents, {
+    availableSkills: Array.from(exposedSkills.values()),
+    availableCommands: Array.from(exposedCmds.values()),
+    hasProjectSkills,
+    hasQualityDoc: input.hasQualityDoc === true
+  });
+  files.push({ path: "AGENTS.md", content: umbrellaContent });
+  if (engines.includes("claude-code")) {
+    files.push({ path: "CLAUDE.md", content: CLAUDE_MD_STUB });
+  }
+  return { files, warnings };
+}
+
+// src/cli/managed-paths.ts
+import { lstatSync, realpathSync, statSync } from "fs";
+import { basename, dirname, isAbsolute, join as join2, resolve, win32 } from "path";
+var MANAGED_FILES = /* @__PURE__ */ new Set([
+  "AGENTS.md",
+  "CLAUDE.md",
+  ".mcp.json",
+  ".harness-manifest.json",
+  ".claude/settings.json",
+  ".codex/config.toml",
+  ".codex/hooks.json",
+  ".opencode/opencode.json",
+  ".opencode/mcp.json"
+]);
+var MANAGED_DIRECTORIES = [
+  ".claude/agents/",
+  ".claude/commands/",
+  ".claude/skills/",
+  ".codex/agents/",
+  ".codex/commands/",
+  ".codex/skills/",
+  ".agents/skills/",
+  ".opencode/agents/",
+  ".opencode/commands/",
+  ".opencode/skills/",
+  ".opencode/plugins/"
+];
+function canonicalTargetRoot(root) {
+  let ancestor = resolve(root);
+  const missing = [];
+  while (!lstatSync(ancestor, { throwIfNoEntry: false })) {
+    missing.unshift(basename(ancestor));
+    ancestor = dirname(ancestor);
+  }
+  const canonical = realpathSync(ancestor);
+  if (!statSync(canonical).isDirectory()) {
+    throw new Error(`harness target is not a directory: ${root}`);
+  }
+  return join2(canonical, ...missing);
+}
+function assertManagedLocation(path) {
+  const invalidSegment = path.split("/").some((part) => part === "" || part === "." || part === "..");
+  if (isAbsolute(path) || win32.isAbsolute(path) || path.includes("\\") || path.includes("\0") || invalidSegment) {
+    throw new Error(`unsafe harness path: ${path}`);
+  }
+  if (!MANAGED_FILES.has(path) && !MANAGED_DIRECTORIES.some((prefix) => path.startsWith(prefix))) {
+    throw new Error(`path is outside harness-managed locations: ${path}`);
+  }
+}
+function assertNoSymbolicComponents(root, path) {
+  const parts = path.split("/");
+  let current = root;
+  for (const [index, part] of parts.entries()) {
+    current = join2(current, part);
+    const info = lstatSync(current, { throwIfNoEntry: false });
+    if (!info) return;
+    if (info.isSymbolicLink()) {
+      throw new Error(`symbolic link in harness path: ${path}`);
+    }
+    const isLeaf = index === parts.length - 1;
+    if (isLeaf ? !info.isFile() : !info.isDirectory()) {
+      throw new Error(`unexpected file type in harness path: ${path}`);
+    }
+  }
+}
+function assertManagedPaths(root, files) {
+  for (const path of files) assertManagedLocation(path);
+  const canonicalRoot = canonicalTargetRoot(root);
+  for (const path of files) assertNoSymbolicComponents(canonicalRoot, path);
+}
+
+// src/cli/manifest.ts
+import { createHash } from "crypto";
+import { chmodSync, existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync } from "fs";
+import { join as join5 } from "path";
+import { z as z5 } from "zod";
+
+// src/version.ts
+var VERSION = "1.3.2";
+
+// src/cli/opencode-config.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+import { isDeepStrictEqual } from "util";
+import { z as z3 } from "zod";
+var OPENCODE_CONFIG_PATH = ".opencode/opencode.json";
+var OPENCODE_SCHEMA = "https://opencode.ai/config.json";
+var ObjectSchema = z3.record(z3.unknown());
+var OpenCodeConfigOwnershipSchema = z3.object({
+  createdFile: z3.boolean(),
+  addedMcp: z3.boolean(),
+  addedSchema: z3.boolean(),
+  entries: z3.record(ObjectSchema)
+});
+function parseConfig(content) {
+  try {
+    const config = ObjectSchema.parse(JSON.parse(content));
+    if (Object.hasOwn(config, "mcp")) ObjectSchema.parse(config.mcp);
+    return config;
+  } catch {
+    throw new Error(`invalid ${OPENCODE_CONFIG_PATH}: expected a JSON object with an MCP object`);
+  }
+}
+function removeOwnedEntries(config, ownership, warnings) {
+  if (Object.hasOwn(config, "mcp")) {
+    const mcp = ObjectSchema.parse(config.mcp);
+    for (const [id, installed] of Object.entries(ownership.entries)) {
+      if (!Object.hasOwn(mcp, id)) continue;
+      if (isDeepStrictEqual(mcp[id], installed)) delete mcp[id];
+      else warnings.push(`preserved modified OpenCode MCP server: ${id}`);
+    }
+    config.mcp = mcp;
+    if (ownership.addedMcp && Object.keys(mcp).length === 0) Reflect.deleteProperty(config, "mcp");
+  }
+  if (ownership.addedSchema && config.$schema === OPENCODE_SCHEMA)
+    Reflect.deleteProperty(config, "$schema");
+}
+function addMissingEntries(config, desired, createdFile, warnings) {
+  const requested = ObjectSchema.parse(parseConfig(desired.content).mcp);
+  const mcp = ObjectSchema.parse(config.mcp ?? {});
+  const entries = {};
+  for (const [id, entry] of Object.entries(requested)) {
+    if (Object.hasOwn(mcp, id)) {
+      if (!isDeepStrictEqual(mcp[id], entry)) {
+        warnings.push(`preserved existing OpenCode MCP server instead of replacing it: ${id}`);
+      }
+      continue;
+    }
+    entries[id] = ObjectSchema.parse(entry);
+    mcp[id] = entry;
+  }
+  if (Object.keys(entries).length === 0) return void 0;
+  const ownership = {
+    createdFile,
+    addedMcp: !Object.hasOwn(config, "mcp"),
+    addedSchema: !Object.hasOwn(config, "$schema"),
+    entries
+  };
+  config.mcp = mcp;
+  if (ownership.addedSchema) config.$schema = OPENCODE_SCHEMA;
+  return ownership;
+}
+function planOpenCodeConfig(root, desired, previous) {
+  const warnings = [];
+  if (!desired && !previous) return { remove: false, warnings };
+  const path = join3(root, OPENCODE_CONFIG_PATH);
+  const existed = existsSync2(path);
+  if (!existed && !desired) return { remove: false, warnings };
+  const original = existed ? readFileSync3(path, "utf8") : void 0;
+  const config = original === void 0 ? {} : parseConfig(original);
+  const before = structuredClone(config);
+  if (previous) removeOwnedEntries(config, previous, warnings);
+  const createdFile = !existed || previous?.createdFile === true;
+  const ownership = desired ? addMissingEntries(config, desired, createdFile, warnings) : void 0;
+  if (!ownership && createdFile && Object.keys(config).length === 0) {
+    return { remove: existed, warnings };
+  }
+  return {
+    remove: false,
+    ownership,
+    warnings,
+    ...!existed || !isDeepStrictEqual(before, config) ? { write: { path: OPENCODE_CONFIG_PATH, content: `${JSON.stringify(config, null, 2)}
+` } } : {}
+  };
+}
+
+// src/cli/update-config.ts
+import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
+import { z as z4 } from "zod";
+var ObjectSchema2 = z4.record(z4.unknown());
+var HookEntrySchema = z4.object({ group: ObjectSchema2, hook: ObjectSchema2 });
+var HookConfigOwnershipSchema = z4.object({
+  createdFile: z4.boolean(),
+  addedHooks: z4.boolean(),
+  addedStop: z4.boolean(),
+  entries: z4.array(HookEntrySchema)
+});
+var HookConfigsOwnershipSchema = z4.object({
+  ".claude/settings.json": HookConfigOwnershipSchema.optional(),
+  ".codex/hooks.json": HookConfigOwnershipSchema.optional()
+}).strict();
+
+// src/cli/manifest.ts
+var MANIFEST_FILENAME = ".harness-manifest.json";
+var MANIFEST_VERSION = "6";
+var ManifestSchema = z5.object({
+  version: z5.enum(["4", "5", MANIFEST_VERSION]),
+  engines: z5.array(z5.string()),
+  renderedAt: z5.string(),
+  files: z5.array(z5.string()),
+  stopHookInstalled: z5.boolean().optional(),
+  stopHookEngines: z5.array(z5.string()).optional(),
+  opencodeConfig: OpenCodeConfigOwnershipSchema.optional(),
+  hookConfigs: HookConfigsOwnershipSchema.optional(),
+  harnessVersion: z5.string().optional(),
+  overridesDir: z5.string().optional(),
+  fileHashes: z5.record(z5.string().regex(/^[a-f0-9]{64}$/)).optional(),
+  preservedFiles: z5.array(z5.string()).optional()
+});
+function manifestPath(targetDir) {
+  return join5(targetDir, MANIFEST_FILENAME);
+}
+function writeManifest(targetDir, engines, files, extras = {}) {
+  assertManagedPaths(targetDir, [MANIFEST_FILENAME]);
+  const manifest = {
+    version: MANIFEST_VERSION,
+    harnessVersion: VERSION,
+    engines: [...engines].sort(),
+    renderedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files: [...files].sort(),
+    fileHashes: Object.fromEntries(
+      files.filter((file) => existsSync4(join5(targetDir, file))).sort().map((file) => [file, hashContent(readFileSync5(join5(targetDir, file)))])
+    ),
+    ...extras.overridesDir ? { overridesDir: extras.overridesDir } : {},
+    ...extras.preservedFiles ? { preservedFiles: extras.preservedFiles } : {},
+    ...extras.hookConfigs ? { hookConfigs: extras.hookConfigs } : {},
+    ...extras.opencodeConfig ? { opencodeConfig: extras.opencodeConfig } : {},
+    ...extras.stopHookInstalled !== void 0 ? { stopHookInstalled: extras.stopHookInstalled } : {},
+    ...extras.stopHookEngines !== void 0 ? { stopHookEngines: [...extras.stopHookEngines].sort() } : {}
+  };
+  const path = manifestPath(targetDir);
+  if (existsSync4(path)) chmodSync(path, 384);
+  writeFileSync(path, `${JSON.stringify(manifest, null, 2)}
+`, { mode: 384 });
+}
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function readManifest(targetDir) {
+  assertManagedPaths(targetDir, [MANIFEST_FILENAME]);
+  const path = manifestPath(targetDir);
+  if (!existsSync4(path)) return null;
+  const raw = JSON.parse(readFileSync5(path, "utf8"));
+  return ManifestSchema.parse(raw);
+}
+
+// src/cli/uninstall.ts
+import { existsSync as existsSync5, readdirSync, rmdirSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join6, relative, resolve as resolve2 } from "path";
+function removeRenderedFiles(root, files) {
+  assertManagedPaths(root, files);
+  const filesRemoved = [];
+  const missing = [];
+  const dirsToConsider = /* @__PURE__ */ new Set();
+  for (const rel of files) {
+    const full = join6(root, rel);
+    if (existsSync5(full)) {
+      unlinkSync(full);
+      filesRemoved.push(rel);
+      dirsToConsider.add(dirname2(full));
+    } else {
+      missing.push(rel);
+    }
+  }
+  return { filesRemoved, dirsPruned: pruneEmptyDirs(root, dirsToConsider), missing };
+}
+function pruneEmptyDirs(root, leaves) {
+  const candidates = /* @__PURE__ */ new Set();
+  for (const leaf of leaves) {
+    let cur = leaf;
+    while (cur !== root && cur.startsWith(`${root}/`)) {
+      candidates.add(cur);
+      cur = dirname2(cur);
+    }
+  }
+  const pruned = [];
+  const sorted = [...candidates].sort((a, b) => b.length - a.length);
+  for (const dir of sorted) {
+    if (!existsSync5(dir)) continue;
+    if (readdirSync(dir).length > 0) continue;
+    rmdirSync(dir);
+    pruned.push(relative(root, dir));
+  }
+  return pruned;
+}
+
+// src/cli/init.ts
+var QUALITY_DOC_PATH = "docs/quality/code-quality.md";
+function resolveEngineList(requested) {
+  if (!requested || requested.length === 0) return [...ENGINES];
+  return requested.map((e) => {
+    if (!ENGINES.includes(e)) {
+      throw new Error(`unknown engine: ${e} (expected one of ${ENGINES.join(", ")})`);
+    }
+    return e;
+  });
+}
+function defaultPackageDir() {
+  const here = dirname3(fileURLToPath(import.meta.url));
+  if (existsSync6(join7(here, "agents"))) return here;
+  return resolve3(here, "..");
+}
+function planInit(args) {
+  const engines = resolveEngineList(args.engines);
+  const packageDir = args.packageDir ?? defaultPackageDir();
+  const harness = loadHarness(packageDir);
+  const overrides = args.overridesDir ? loadOverrides(args.overridesDir) : void 0;
+  const projectSkills = loadProjectSkills(args.targetDir);
+  const hasQualityDoc = existsSync6(join7(args.targetDir, QUALITY_DOC_PATH));
+  const mcpServers = args.mcpServers ? resolveMcpIds(args.mcpServers) : void 0;
+  const stopHookInstalled = args.withStopHook !== false;
+  const output = render({
+    harness,
+    engines,
+    overrides,
+    projectSkills,
+    hasQualityDoc,
+    mcpServers,
+    withStopHook: stopHookInstalled
+  });
+  return { engines, output, stopHookInstalled };
+}
+function writeFilesToTarget(files, targetDir) {
+  assertManagedPaths(
+    targetDir,
+    files.map((file) => file.path)
+  );
+  const written = [];
+  for (const f of files) {
+    const full = join7(targetDir, f.path);
+    mkdirSync(dirname3(full), { recursive: true });
+    writeFileSync3(full, f.content);
+    written.push(f.path);
+  }
+  return written;
+}
+function initCommand(args) {
+  const { engines, output, stopHookInstalled } = planInit(args);
+  const previous = readManifest(args.targetDir);
+  assertManagedPaths(args.targetDir, [
+    MANIFEST_FILENAME,
+    ...previous?.files ?? [],
+    ...output.files.map((file) => file.path),
+    ...previous?.opencodeConfig ? [OPENCODE_CONFIG_PATH] : []
+  ]);
+  const desiredConfig = output.files.find((file) => file.path === OPENCODE_CONFIG_PATH);
+  const config = planOpenCodeConfig(args.targetDir, desiredConfig, previous?.opencodeConfig);
+  const next = new Set(output.files.map((f) => f.path));
+  const stale = (previous?.files ?? []).filter((f) => !next.has(f) && f !== OPENCODE_CONFIG_PATH);
+  if (config.remove) stale.push(OPENCODE_CONFIG_PATH);
+  const staleFilesRemoved = removeRenderedFiles(resolve3(args.targetDir), stale).filesRemoved;
+  const ownedFiles = output.files.filter((file) => file.path !== OPENCODE_CONFIG_PATH);
+  const filesWritten = writeFilesToTarget(ownedFiles, args.targetDir);
+  if (config.write) writeFilesToTarget([config.write], args.targetDir);
+  writeManifest(args.targetDir, engines, filesWritten, {
+    stopHookInstalled,
+    stopHookEngines: stopHookInstalled ? engines : void 0,
+    opencodeConfig: config.ownership,
+    overridesDir: args.overridesDir ? resolve3(args.overridesDir) === resolve3(args.targetDir) ? "." : resolve3(args.overridesDir) : void 0
+  });
+  if (config.write) filesWritten.push(OPENCODE_CONFIG_PATH);
+  const warnings = [...output.warnings, ...config.warnings];
+  if (previous?.files.includes(OPENCODE_CONFIG_PATH) && !previous.opencodeConfig) {
+    warnings.push(`preserved legacy shared configuration: ${OPENCODE_CONFIG_PATH}`);
+  }
+  return { filesWritten, staleFilesRemoved, warnings, stopHookInstalled };
+}
+export {
+  initCommand,
+  planInit,
+  writeFilesToTarget
+};
+//# sourceMappingURL=init.js.map