harnessed 3.4.1 → 3.4.3

package/dist/cli.mjs

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import { execSync, spawnSync, spawn } from 'child_process';
-import { existsSync, mkdirSync, renameSync, writeFileSync, readFileSync, appendFileSync, readdirSync } from 'fs';
+import { existsSync, mkdirSync, renameSync, writeFileSync, readFileSync, readdirSync, appendFileSync } from 'fs';
 import { join, resolve, dirname, relative } from 'path';
 import { homedir } from 'os';
 import { Type } from '@sinclair/typebox';
 import { Value } from '@sinclair/typebox/value';
 import { LineCounter, parseDocument, parse, isSeq, isScalar } from 'yaml';
-import { readFile, readdir, unlink, writeFile, stat, rm, cp, access, mkdir, rename } from 'fs/promises';
+import { readFile, readdir, unlink, writeFile, stat, rm, cp, mkdir, access, rename } from 'fs/promises';
 import lockfile from 'proper-lockfile';
 import { Command } from 'commander';
 import { Ajv } from 'ajv';
@@ -847,7 +847,7 @@ var init_resume = __esm({
 
 // package.json
 var package_default = {
-  version: "3.4.1"};
+  version: "3.4.3"};
 
 // src/manifest/errors.ts
 function instancePathToKeyPath(instancePath) {
@@ -4854,6 +4854,109 @@ ${t("rollback.metadata_unreadable.fix")}`
     console.log(t("rollback.restored", { count: meta.files.length, timestamp }));
   });
 }
+function readInstalledPlugins(homedirOverride) {
+  const home = homedir();
+  const path = join(home, ".claude", "plugins", "installed_plugins.json");
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+  if (!parsed || typeof parsed !== "object") return /* @__PURE__ */ new Set();
+  const plugins = parsed.plugins;
+  if (!plugins || typeof plugins !== "object") return /* @__PURE__ */ new Set();
+  const out = /* @__PURE__ */ new Set();
+  for (const key of Object.keys(plugins)) {
+    const at = key.indexOf("@");
+    if (at <= 0) continue;
+    out.add(key.slice(0, at));
+  }
+  return out;
+}
+function readInstalledUserSkills(homedirOverride) {
+  const home = homedir();
+  const skillsRoot = join(home, ".claude", "skills");
+  try {
+    const entries = readdirSync(skillsRoot, { withFileTypes: true });
+    const out = /* @__PURE__ */ new Set();
+    for (const e of entries) if (e.isDirectory()) out.add(e.name);
+    return out;
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function resolveCapabilityCmd(capability, installedPlugins, installedUserSkills) {
+  const { cmd, install_type, plugin_id, skill_dir } = capability;
+  if (!install_type) return { renderedCmd: cmd };
+  const types = Array.isArray(install_type) ? install_type : [install_type];
+  const uniqueTypes = [...new Set(types)];
+  const missingHints = [];
+  let anyDetected = false;
+  for (const t2 of uniqueTypes) {
+    if (t2 === "plugin") {
+      if (!plugin_id) {
+        missingHints.push(
+          `install_type=plugin declared but no plugin_id (capabilities.yaml schema bug)`
+        );
+        continue;
+      }
+      if (installedPlugins.has(plugin_id)) {
+        anyDetected = true;
+        break;
+      }
+      missingHints.push(`plugin '${plugin_id}' (\`claude plugin install ${plugin_id}\`)`);
+    } else {
+      if (!skill_dir) {
+        missingHints.push(
+          `install_type=user-skill declared but no skill_dir (capabilities.yaml schema bug)`
+        );
+        continue;
+      }
+      if (installedUserSkills.has(skill_dir)) {
+        anyDetected = true;
+        break;
+      }
+      missingHints.push(
+        `user-skill '${skill_dir}' under ~/.claude/skills/ (git clone the official repo; e.g. gstack: \`git clone https://github.com/garrytan/gstack.git ~/.claude/skills/gstack && cd ~/.claude/skills/gstack && ./setup\`)`
+      );
+    }
+  }
+  if (anyDetected) return { renderedCmd: cmd };
+  const prefix = uniqueTypes.length > 1 ? "[multi]" : `[${uniqueTypes[0]}]`;
+  const joined = missingHints.join(" OR ");
+  return {
+    renderedCmd: cmd,
+    warning: `${prefix} '${cmd}' backing missing \u2014 install either: ${joined}.`
+  };
+}
+var CAPABILITY_CMD_TEMPLATE = /\{\{\s*capabilities\.([a-zA-Z0-9_-]+)\.cmd\s*\}\}/g;
+function renderSkillBody(body, capabilities, installedPlugins, installedUserSkills) {
+  const warningsSet = /* @__PURE__ */ new Set();
+  const out = body.replace(CAPABILITY_CMD_TEMPLATE, (match2, name) => {
+    const cap = capabilities[name];
+    if (!cap) {
+      warningsSet.add(
+        `capability '${name}' referenced in SKILL.md but not defined in capabilities.yaml`
+      );
+      return match2;
+    }
+    const { renderedCmd, warning } = resolveCapabilityCmd(
+      cap,
+      installedPlugins,
+      installedUserSkills
+    );
+    if (warning) warningsSet.add(warning);
+    return renderedCmd;
+  });
+  return { body: out, warnings: [...warningsSet] };
+}
 
 // src/cli/lib/enableAgentTeamsInSettings.ts
 init_harnessedRoot();
@@ -5020,72 +5123,121 @@ async function atomicWrite2(path, content) {
     return `write ${path} failed: ${err2.message}`;
   }
 }
-function readInstalledPlugins(homedirOverride) {
-  const home = homedir();
-  const path = join(home, ".claude", "plugins", "installed_plugins.json");
+async function loadRolePrompts(workflowsDir) {
+  const path = join(workflowsDir, "role-prompts.yaml");
   let raw;
   try {
-    raw = readFileSync(path, "utf8");
-  } catch {
-    return /* @__PURE__ */ new Set();
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
+    raw = await readFile(path, "utf8");
   } catch {
-    return /* @__PURE__ */ new Set();
-  }
-  if (!parsed || typeof parsed !== "object") return /* @__PURE__ */ new Set();
-  const plugins = parsed.plugins;
-  if (!plugins || typeof plugins !== "object") return /* @__PURE__ */ new Set();
-  const out = /* @__PURE__ */ new Set();
-  for (const key of Object.keys(plugins)) {
-    const at = key.indexOf("@");
-    if (at <= 0) continue;
-    out.add(key.slice(0, at));
-  }
-  return out;
-}
-function resolveCapabilityCmd(capability, installedPlugins) {
-  const { cmd, plugin_namespace } = capability;
-  if (!plugin_namespace) return { renderedCmd: cmd };
-  if (cmd.includes(":")) return { renderedCmd: cmd };
-  if (!cmd.startsWith("/")) return { renderedCmd: cmd };
-  if (!installedPlugins.has(plugin_namespace)) {
-    return {
-      renderedCmd: cmd,
-      warning: `plugin '${plugin_namespace}' not installed \u2014 '${cmd}' will not resolve via Claude Code. install: 'claude plugin install ${plugin_namespace}' or see plugin docs.`
-    };
+    return {};
   }
-  const bare = cmd.slice(1);
-  return { renderedCmd: `/${plugin_namespace}:${bare}` };
+  const doc = parse(raw);
+  return doc?.prompts ?? {};
+}
+function generateCommandFile(name, prompt, capabilities, installedPlugins, installedUserSkills) {
+  const isMaster = prompt.is_master === true;
+  const primaryCmdLine = prompt.primary_cap && capabilities[prompt.primary_cap] ? `{{ capabilities.${prompt.primary_cap}.cmd }}` : "";
+  const checklistBlock = prompt.checklist.length ? prompt.checklist.map((item, i) => `> ${i + 1}. ${item}`).join("\n>\n") : "> (Master orchestrator \u2014 dispatches to per-sub-workflow slash commands listed below.)";
+  const fallbackPath = isMaster ? `**Fallback path** (when no slash command from the sub-list resolves): run each missing sub-workflow inline using its own role prompt (see \`~/.claude/skills/<sub-name>/SKILL.md\` for the per-sub fallback prompt). Do NOT skip stages silently \u2014 each sub either runs or is logged as "skipped: <reason>".` : [
+    `**Fallback path** (when the upstream isn't installed or returns no result): use the Task tool to spawn a general-purpose subagent with this prompt:`,
+    ``,
+    `> You are a **${prompt.specialist}**.`,
+    `>`,
+    `> **Mission**: ${prompt.responsibility.trim().replace(/\n/g, " ")}`,
+    `>`,
+    `> **Default-suspect mode**: assume the change is broken / risky / incomplete until proven otherwise. Cite \`file:line\` for every finding; do not generalize.`,
+    `>`,
+    `> **Review checklist**:`,
+    checklistBlock,
+    `>`,
+    `> **Output format**: structured report with severity-classified findings (${prompt.severity}). One finding per line: \`[severity] file:line \u2014 problem (one sentence); fix: suggested change\`. If no findings, say so explicitly. No preamble, no end-of-report summary.`,
+    ``,
+    `(The role prompt is self-contained \u2014 works even when the upstream \`${prompt.primary_cap || "specialist"}\` user-skill / plugin isn't installed.)`
+  ].join("\n");
+  const preferredPath = primaryCmdLine ? `**Preferred path** (when the upstream specialist is installed): use the SlashCommand tool to run \`${primaryCmdLine}\` \u2014 the upstream specialist takes over.` : `**Preferred path** (master orchestrator): dispatch to the per-sub-workflow slash commands in the order this stage prescribes. Each sub command is its own \`~/.claude/commands/<sub-name>.md\` and has its own dual-path fallback.`;
+  const rawBody = [
+    `# /${name}`,
+    ``,
+    prompt.description,
+    ``,
+    `## How to invoke`,
+    ``,
+    preferredPath,
+    ``,
+    fallbackPath,
+    ``,
+    `## Notes`,
+    ``,
+    `- This file (\`~/.claude/commands/${name}.md\`) is generated by \`harnessed setup\` from \`workflows/role-prompts.yaml\` + \`workflows/<stage>/<sub>/SKILL.md\`. To regenerate after a harnessed upgrade, re-run \`harnessed setup\`.`,
+    `- The companion \`~/.claude/skills/${name}/SKILL.md\` is the Skill-tool entry point (Claude loads it when triggers match \`trigger_phrases:\`). Both files carry the same dual-path instruction.`,
+    `- If your shell shows a \`\u26A0\uFE0F ... not installed\` warning from \`harnessed setup\` for this command, the upstream is missing on disk \u2014 install per the warning, OR rely on the fallback Task-spawn role prompt above (it does not require the upstream).`,
+    ``
+  ].join("\n");
+  const { body, warnings } = renderSkillBody(
+    rawBody,
+    capabilities,
+    installedPlugins,
+    installedUserSkills
+  );
+  const frontmatter = ["---", `description: ${JSON.stringify(prompt.description)}`, "---", ""].join(
+    "\n"
+  );
+  return { content: frontmatter + body, warnings };
 }
-var CAPABILITY_CMD_TEMPLATE = /\{\{\s*capabilities\.([a-zA-Z0-9_-]+)\.cmd\s*\}\}/g;
-function renderSkillBody(body, capabilities, installedPlugins) {
-  const warningsSet = /* @__PURE__ */ new Set();
-  const out = body.replace(CAPABILITY_CMD_TEMPLATE, (match2, name) => {
-    const cap = capabilities[name];
-    if (!cap) {
-      warningsSet.add(
-        `capability '${name}' referenced in SKILL.md but not defined in capabilities.yaml`
-      );
-      return match2;
+async function writeAllCommands(slashNames, commandsDir, rolePrompts, capabilities, installedPlugins, installedUserSkills, writer, fileExists = existsSync) {
+  const results = [];
+  const aggregatedWarnings = /* @__PURE__ */ new Set();
+  for (const name of slashNames) {
+    const path = join(commandsDir, `${name}.md`);
+    const prompt = rolePrompts[name];
+    if (!prompt) {
+      results.push({
+        name,
+        path,
+        written: false,
+        warning: `no role-prompts.yaml entry for '${name}' \u2014 skipping commands/${name}.md generation`
+      });
+      aggregatedWarnings.add(`role-prompts.yaml missing entry for '${name}'`);
+      continue;
     }
-    const { renderedCmd, warning } = resolveCapabilityCmd(cap, installedPlugins);
-    if (warning) warningsSet.add(warning);
-    return renderedCmd;
-  });
-  return { body: out, warnings: [...warningsSet] };
+    if (fileExists(path)) {
+      results.push({
+        name,
+        path,
+        written: false,
+        warning: `commands/${name}.md already exists \u2014 leaving user file unchanged`
+      });
+      continue;
+    }
+    const { content, warnings } = generateCommandFile(
+      name,
+      prompt,
+      capabilities,
+      installedPlugins,
+      installedUserSkills
+    );
+    try {
+      await writer(path, content);
+      results.push({ name, path, written: true });
+    } catch (e) {
+      results.push({
+        name,
+        path,
+        written: false,
+        warning: `write failed for commands/${name}.md: ${e.message}`
+      });
+    }
+    for (const w of warnings) aggregatedWarnings.add(w);
+  }
+  return { results, warnings: [...aggregatedWarnings] };
 }
-
-// src/cli/lib/renderSkillTemplates.ts
 async function loadCapabilities(workflowsDir) {
   const path = join(workflowsDir, "capabilities.yaml");
   const raw = await readFile(path, "utf8");
   const doc = parse(raw);
   return doc?.capabilities ?? {};
 }
-async function renderSkillFile(skillName, skillsBase, capabilities, installedPlugins) {
+async function renderSkillFile(skillName, skillsBase, capabilities, installedPlugins, installedUserSkills) {
   const skillPath = join(skillsBase, skillName, "SKILL.md");
   const result = {
     name: skillName,
@@ -5100,7 +5252,7 @@ async function renderSkillFile(skillName, skillsBase, capabilities, installedPlu
     result.error = `read failed: ${e.message}`;
     return result;
   }
-  const rendered = renderSkillBody(body, capabilities, installedPlugins);
+  const rendered = renderSkillBody(body, capabilities, installedPlugins, installedUserSkills);
   if (rendered.body === body) {
     result.warnings = rendered.warnings;
     return result;
@@ -5133,10 +5285,17 @@ async function renderAllSkills(skillNames, skillsBase, workflowsDir, homedirOver
     };
   }
   const installedPlugins = readInstalledPlugins();
+  const installedUserSkills = readInstalledUserSkills();
   const results = [];
   const warningSet = /* @__PURE__ */ new Set();
   for (const name of skillNames) {
-    const r = await renderSkillFile(name, skillsBase, capabilities, installedPlugins);
+    const r = await renderSkillFile(
+      name,
+      skillsBase,
+      capabilities,
+      installedPlugins,
+      installedUserSkills
+    );
     results.push(r);
     for (const w of r.warnings) warningSet.add(w);
     if (r.error) warningSet.add(`${name}: ${r.error}`);
@@ -5378,6 +5537,46 @@ function registerSetup(program2) {
         console.warn(`    - ${w}`);
       }
     }
+    const commandsBase = resolve(homedir(), ".claude", "commands");
+    try {
+      await mkdir(commandsBase, { recursive: true });
+    } catch (e) {
+      console.warn(
+        `  [A.6] could not create ${commandsBase} \u2014 skipping commands/ generation (${e.message})`
+      );
+    }
+    let capabilitiesMap = {};
+    try {
+      capabilitiesMap = await loadCapabilities(workflowsDir);
+    } catch (e) {
+      console.warn(
+        `  [A.6] capabilities.yaml unreadable \u2014 skipping commands/ generation (${e.message})`
+      );
+    }
+    const rolePrompts = await loadRolePrompts(workflowsDir);
+    const installedPlugins = readInstalledPlugins();
+    const installedUserSkills = readInstalledUserSkills();
+    const cmdResult = await writeAllCommands(
+      skillNames,
+      commandsBase,
+      rolePrompts,
+      capabilitiesMap,
+      installedPlugins,
+      installedUserSkills,
+      async (p4, c) => writeFile(p4, c, "utf8")
+    );
+    const writtenCount = cmdResult.results.filter((r) => r.written).length;
+    const skippedCount = cmdResult.results.filter((r) => !r.written && r.warning).length;
+    console.log(
+      `  [A.6] generated ${writtenCount} commands/<x>.md file(s) (${skippedCount} skipped \u2014 existing user file or schema warn)`
+    );
+    for (const r of cmdResult.results) {
+      if (r.written) {
+        console.log(`  [A.6] wrote /${r.name}  \u2192  ${r.path}`);
+      } else if (r.warning) {
+        console.warn(`  [A.6] skipped /${r.name}: ${r.warning}`);
+      }
+    }
     const cResult = await enableAgentTeamsInSettings();
     if (cResult.status === "created") {
       console.log(t("setup.step_c.created", { path: cResult.path }));