@cydm/pie 1.0.5 → 1.0.7

package/dist/builtin/skills/skill-creator/eval-viewer/generate_review.mjs

@@ -0,0 +1,285 @@
+#!/usr/bin/env node
+
+import path from "node:path";
+import { createServer } from "node:http";
+import { readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { openInBrowser } from "../scripts/claude_cli.mjs";
+
+const execFileAsync = promisify(execFile);
+const METADATA_FILES = new Set(["transcript.md", "user_notes.md", "metrics.json"]);
+const TEXT_EXTENSIONS = new Set([".txt", ".md", ".json", ".csv", ".py", ".js", ".ts", ".tsx", ".jsx", ".yaml", ".yml", ".xml", ".html", ".css", ".sh", ".rb", ".go", ".rs", ".java", ".c", ".cpp", ".h", ".hpp", ".sql", ".r", ".toml", ".mjs"]);
+const IMAGE_EXTENSIONS = new Set([".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp"]);
+const MIME_OVERRIDES = {
+  ".svg": "image/svg+xml",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+};
+
+function getMimeType(targetPath) {
+  const extension = path.extname(targetPath).toLowerCase();
+  return MIME_OVERRIDES[extension] ?? "application/octet-stream";
+}
+
+async function pathExists(targetPath) {
+  try {
+    await stat(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readJsonIfExists(targetPath) {
+  if (!(await pathExists(targetPath))) return null;
+  try {
+    return JSON.parse(await readFile(targetPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export async function findRuns(workspace) {
+  const runs = [];
+  await findRunsRecursive(workspace, workspace, runs);
+  runs.sort((a, b) => (a.eval_id ?? Number.MAX_SAFE_INTEGER) - (b.eval_id ?? Number.MAX_SAFE_INTEGER) || a.id.localeCompare(b.id));
+  return runs;
+}
+
+async function findRunsRecursive(root, current, runs) {
+  if (!(await pathExists(current))) return;
+  const currentStat = await stat(current);
+  if (!currentStat.isDirectory()) return;
+  const outputsDir = path.join(current, "outputs");
+  if (await pathExists(outputsDir)) {
+    const builtRun = await buildRun(root, current);
+    if (builtRun) {
+      runs.push(builtRun);
+    }
+    return;
+  }
+  const entries = await readdir(current, { withFileTypes: true });
+  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    if (!entry.isDirectory()) continue;
+    if (new Set(["node_modules", ".git", "__pycache__", "skill", "inputs"]).has(entry.name)) continue;
+    await findRunsRecursive(root, path.join(current, entry.name), runs);
+  }
+}
+
+async function buildRun(root, runDir) {
+  let prompt = "";
+  let evalId = null;
+  for (const candidate of [path.join(runDir, "eval_metadata.json"), path.join(path.dirname(runDir), "eval_metadata.json")]) {
+    const metadata = await readJsonIfExists(candidate);
+    if (metadata?.prompt) {
+      prompt = metadata.prompt;
+      evalId = metadata.eval_id ?? null;
+      break;
+    }
+  }
+  if (!prompt) {
+    for (const candidate of [path.join(runDir, "transcript.md"), path.join(runDir, "outputs", "transcript.md")]) {
+      if (!(await pathExists(candidate))) continue;
+      const text = await readFile(candidate, "utf8");
+      const match = text.match(/## Eval Prompt\n\n([\s\S]*?)(?=\n##|$)/);
+      if (match?.[1]) {
+        prompt = match[1].trim();
+        break;
+      }
+    }
+  }
+  if (!prompt) {
+    prompt = "(No prompt found)";
+  }
+  const outputFiles = [];
+  const outputsDir = path.join(runDir, "outputs");
+  if (await pathExists(outputsDir)) {
+    const entries = await readdir(outputsDir, { withFileTypes: true });
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      if (!entry.isFile() || METADATA_FILES.has(entry.name)) continue;
+      outputFiles.push(await embedFile(path.join(outputsDir, entry.name)));
+    }
+  }
+  const grading = await readJsonIfExists(path.join(runDir, "grading.json")) ?? await readJsonIfExists(path.join(path.dirname(runDir), "grading.json"));
+  return {
+    id: path.relative(root, runDir).replaceAll(path.sep, "-"),
+    prompt,
+    eval_id: evalId,
+    outputs: outputFiles,
+    grading,
+  };
+}
+
+async function embedFile(targetPath) {
+  const extension = path.extname(targetPath).toLowerCase();
+  if (TEXT_EXTENSIONS.has(extension)) {
+    return { name: path.basename(targetPath), type: "text", content: await readFile(targetPath, "utf8").catch(() => "(Error reading file)") };
+  }
+  const raw = await readFile(targetPath).catch(() => null);
+  if (!raw) {
+    return { name: path.basename(targetPath), type: "error", content: "(Error reading file)" };
+  }
+  const mime = getMimeType(targetPath);
+  const data = raw.toString("base64");
+  if (IMAGE_EXTENSIONS.has(extension)) {
+    return { name: path.basename(targetPath), type: "image", mime, data_uri: `data:${mime};base64,${data}` };
+  }
+  if (extension === ".pdf") {
+    return { name: path.basename(targetPath), type: "pdf", data_uri: `data:${mime};base64,${data}` };
+  }
+  if (extension === ".xlsx") {
+    return { name: path.basename(targetPath), type: "xlsx", data_b64: data };
+  }
+  return { name: path.basename(targetPath), type: "binary", mime, data_uri: `data:${mime};base64,${data}` };
+}
+
+export async function loadPreviousIteration(workspace) {
+  const result = {};
+  const feedback = await readJsonIfExists(path.join(workspace, "feedback.json"));
+  const feedbackMap = new Map();
+  for (const review of feedback?.reviews ?? []) {
+    if (review?.run_id && String(review.feedback ?? "").trim()) {
+      feedbackMap.set(review.run_id, review.feedback);
+    }
+  }
+  for (const run of await findRuns(workspace)) {
+    result[run.id] = {
+      feedback: feedbackMap.get(run.id) ?? "",
+      outputs: run.outputs ?? [],
+    };
+  }
+  for (const [runId, reviewFeedback] of feedbackMap.entries()) {
+    if (!result[runId]) {
+      result[runId] = { feedback: reviewFeedback, outputs: [] };
+    }
+  }
+  return result;
+}
+
+export async function generateHtml({ workspace, skillName, previous = null, benchmark = null }) {
+  const templatePath = path.join(path.dirname(fileURLToPath(import.meta.url)), "viewer.html");
+  const template = await readFile(templatePath, "utf8");
+  const runs = await findRuns(workspace);
+  const previousFeedback = {};
+  const previousOutputs = {};
+  if (previous) {
+    for (const [runId, data] of Object.entries(previous)) {
+      if (data.feedback) previousFeedback[runId] = data.feedback;
+      if (Array.isArray(data.outputs) && data.outputs.length > 0) previousOutputs[runId] = data.outputs;
+    }
+  }
+  const embedded = { skill_name: skillName, runs, previous_feedback: previousFeedback, previous_outputs: previousOutputs };
+  if (benchmark) {
+    embedded.benchmark = benchmark;
+  }
+  return template.replace("/*__EMBEDDED_DATA__*/", `const EMBEDDED_DATA = ${JSON.stringify(embedded)};`);
+}
+
+async function killPort(port) {
+  try {
+    const { stdout } = await execFileAsync("lsof", ["-ti", `:${port}`], { timeout: 5000 });
+    for (const pid of stdout.split("\n").map((value) => value.trim()).filter(Boolean)) {
+      try {
+        process.kill(Number(pid), "SIGTERM");
+      } catch {}
+    }
+  } catch {}
+}
+
+function parseArgs(args) {
+  const flags = { _: [] };
+  for (let i = 0; i < args.length; i += 1) {
+    const item = args[i];
+    if (!item.startsWith("-")) {
+      flags._.push(item);
+      continue;
+    }
+    const key = item.startsWith("--") ? item.slice(2) : item.slice(1);
+    const next = args[i + 1];
+    if (!next || next.startsWith("-")) {
+      flags[key] = true;
+      continue;
+    }
+    flags[key] = next;
+    i += 1;
+  }
+  return flags;
+}
+
+async function main(argv = process.argv) {
+  const args = parseArgs(argv.slice(2));
+  const workspace = path.resolve(args._[0] ?? "");
+  if (!workspace) {
+    throw new Error("Usage: node generate_review.mjs <workspace-path> [--port PORT] [--skill-name NAME] [--static output.html]");
+  }
+  const skillName = args["skill-name"] ?? path.basename(workspace).replace(/-workspace$/, "");
+  const previous = args["previous-workspace"] ? await loadPreviousIteration(path.resolve(args["previous-workspace"])) : {};
+  const benchmark = args.benchmark ? await readJsonIfExists(path.resolve(args.benchmark)) : null;
+  if (args.static || args.s) {
+    const outputPath = path.resolve(args.static ?? args.s);
+    await writeFile(outputPath, await generateHtml({ workspace, skillName, previous, benchmark }));
+    process.stdout.write(`Static viewer written to: ${outputPath}\n`);
+    return;
+  }
+  let port = Number(args.port ?? args.p ?? 3117);
+  await killPort(port);
+  const feedbackPath = path.join(workspace, "feedback.json");
+  const server = createServer(async (req, res) => {
+    try {
+      if (req.method === "GET" && (req.url === "/" || req.url === "/index.html")) {
+        const html = await generateHtml({ workspace, skillName, previous, benchmark });
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(html);
+        return;
+      }
+      if (req.method === "GET" && req.url === "/api/feedback") {
+        const feedback = await readFile(feedbackPath, "utf8").catch(() => "{}");
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(feedback);
+        return;
+      }
+      if (req.method === "POST" && req.url === "/api/feedback") {
+        let body = "";
+        req.setEncoding("utf8");
+        for await (const chunk of req) {
+          body += chunk;
+        }
+        const parsed = JSON.parse(body);
+        if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.reviews)) {
+          throw new Error("Expected JSON object with 'reviews' key");
+        }
+        await writeFile(feedbackPath, `${JSON.stringify(parsed, null, 2)}\n`);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end("{\"ok\":true}");
+        return;
+      }
+      res.writeHead(404);
+      res.end("Not found");
+    } catch (error) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+    }
+  });
+  await new Promise((resolve) => {
+    server.once("error", () => {
+      server.listen(0, "127.0.0.1", resolve);
+    });
+    server.listen(port, "127.0.0.1", resolve);
+  });
+  const address = server.address();
+  port = typeof address === "object" && address ? address.port : port;
+  const url = `http://localhost:${port}`;
+  process.stdout.write(`Eval Viewer\nURL: ${url}\nWorkspace: ${workspace}\nFeedback: ${feedbackPath}\n`);
+  await openInBrowser(url);
+}
+
+const entryPath = fileURLToPath(import.meta.url);
+if (process.argv[1] && path.resolve(process.argv[1]) === entryPath) {
+  main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+  });
+}

package/dist/builtin/skills/skill-creator/eval-viewer/viewer.html

@@ -645,7 +645,7 @@
   <div class="toast" id="toast"></div>
 
   <script>
-    // ---- Embedded data (injected by generate_review.py) ----
+    // ---- Embedded data (injected by generate_review.mjs) ----
     /*__EMBEDDED_DATA__*/
 
     // ---- State ----

package/dist/builtin/skills/skill-creator/scripts/aggregate_benchmark.mjs

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+
+import path from "node:path";
+import { readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+function round(value, places = 4) {
+  const factor = 10 ** places;
+  return Math.round(value * factor) / factor;
+}
+
+export function calculateStats(values) {
+  if (!Array.isArray(values) || values.length === 0) {
+    return { mean: 0, stddev: 0, min: 0, max: 0 };
+  }
+  const mean = values.reduce((sum, value) => sum + value, 0) / values.length;
+  let stddev = 0;
+  if (values.length > 1) {
+    const variance = values.reduce((sum, value) => sum + ((value - mean) ** 2), 0) / (values.length - 1);
+    stddev = Math.sqrt(variance);
+  }
+  return {
+    mean: round(mean, 4),
+    stddev: round(stddev, 4),
+    min: round(Math.min(...values), 4),
+    max: round(Math.max(...values), 4),
+  };
+}
+
+async function pathExists(targetPath) {
+  try {
+    await stat(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readJsonIfExists(targetPath) {
+  if (!(await pathExists(targetPath))) {
+    return null;
+  }
+  try {
+    return JSON.parse(await readFile(targetPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+async function listDirectories(targetPath) {
+  const entries = await readdir(targetPath, { withFileTypes: true });
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+}
+
+export async function loadRunResults(benchmarkDir) {
+  const runsDir = path.join(benchmarkDir, "runs");
+  const benchmarkEvalDirs = (await pathExists(benchmarkDir))
+    ? (await listDirectories(benchmarkDir)).filter((name) => name.startsWith("eval-"))
+    : [];
+  let searchDir = null;
+  if (await pathExists(runsDir)) {
+    searchDir = runsDir;
+  } else if (benchmarkEvalDirs.length > 0) {
+    searchDir = benchmarkDir;
+  } else {
+    return {};
+  }
+
+  const results = {};
+  const evalDirs = (await listDirectories(searchDir)).filter((name) => name.startsWith("eval-"));
+  for (const [evalIdx, evalDirName] of evalDirs.entries()) {
+    const evalDir = path.join(searchDir, evalDirName);
+    const metadata = await readJsonIfExists(path.join(evalDir, "eval_metadata.json"));
+    const parsedEvalId = Number.parseInt(evalDirName.split("-")[1], 10);
+    const evalId = metadata?.eval_id ?? (Number.isNaN(parsedEvalId) ? evalIdx : parsedEvalId);
+    for (const configName of await listDirectories(evalDir)) {
+      const configDir = path.join(evalDir, configName);
+      const childDirs = await listDirectories(configDir);
+      const runDirs = childDirs.filter((name) => name.startsWith("run-"));
+      if (runDirs.length === 0) {
+        continue;
+      }
+      if (!results[configName]) {
+        results[configName] = [];
+      }
+      for (const runDirName of runDirs) {
+        const runDir = path.join(configDir, runDirName);
+        const grading = await readJsonIfExists(path.join(runDir, "grading.json"));
+        if (!grading) {
+          continue;
+        }
+        const timing = grading.timing ?? {};
+        let timeSeconds = Number(timing.total_duration_seconds ?? 0);
+        let tokens = 0;
+        const timingJson = await readJsonIfExists(path.join(runDir, "timing.json"));
+        if (timeSeconds === 0 && timingJson) {
+          timeSeconds = Number(timingJson.total_duration_seconds ?? 0);
+          tokens = Number(timingJson.total_tokens ?? 0);
+        }
+        const executionMetrics = grading.execution_metrics ?? {};
+        if (tokens === 0) {
+          tokens = Number(executionMetrics.output_chars ?? 0);
+        }
+        results[configName].push({
+          eval_id: evalId,
+          run_number: Number.parseInt(runDirName.split("-")[1], 10) || 0,
+          pass_rate: Number(grading.summary?.pass_rate ?? 0),
+          passed: Number(grading.summary?.passed ?? 0),
+          failed: Number(grading.summary?.failed ?? 0),
+          total: Number(grading.summary?.total ?? 0),
+          time_seconds: timeSeconds,
+          tokens,
+          tool_calls: Number(executionMetrics.total_tool_calls ?? 0),
+          errors: Number(executionMetrics.errors_encountered ?? 0),
+          expectations: Array.isArray(grading.expectations) ? grading.expectations : [],
+          notes: [
+            ...(grading.user_notes_summary?.uncertainties ?? []),
+            ...(grading.user_notes_summary?.needs_review ?? []),
+            ...(grading.user_notes_summary?.workarounds ?? []),
+          ],
+        });
+      }
+    }
+  }
+  return results;
+}
+
+export function aggregateResults(results) {
+  const runSummary = {};
+  const configs = Object.keys(results);
+  for (const config of configs) {
+    const runs = results[config] ?? [];
+    runSummary[config] = {
+      pass_rate: calculateStats(runs.map((run) => Number(run.pass_rate ?? 0))),
+      time_seconds: calculateStats(runs.map((run) => Number(run.time_seconds ?? 0))),
+      tokens: calculateStats(runs.map((run) => Number(run.tokens ?? 0))),
+    };
+  }
+  const primaryConfig = configs[0];
+  const baselineConfig = configs[1];
+  const primary = runSummary[primaryConfig] ?? {};
+  const baseline = runSummary[baselineConfig] ?? {};
+  runSummary.delta = {
+    pass_rate: `${(primary.pass_rate?.mean ?? 0) - (baseline.pass_rate?.mean ?? 0) >= 0 ? "+" : ""}${round((primary.pass_rate?.mean ?? 0) - (baseline.pass_rate?.mean ?? 0), 2).toFixed(2)}`,
+    time_seconds: `${(primary.time_seconds?.mean ?? 0) - (baseline.time_seconds?.mean ?? 0) >= 0 ? "+" : ""}${round((primary.time_seconds?.mean ?? 0) - (baseline.time_seconds?.mean ?? 0), 1).toFixed(1)}`,
+    tokens: `${(primary.tokens?.mean ?? 0) - (baseline.tokens?.mean ?? 0) >= 0 ? "+" : ""}${Math.round((primary.tokens?.mean ?? 0) - (baseline.tokens?.mean ?? 0))}`,
+  };
+  return runSummary;
+}
+
+export async function generateBenchmark(benchmarkDir, { skillName = "", skillPath = "" } = {}) {
+  const results = await loadRunResults(benchmarkDir);
+  const runSummary = aggregateResults(results);
+  const runs = [];
+  for (const [configuration, entries] of Object.entries(results)) {
+    for (const result of entries) {
+      runs.push({
+        eval_id: result.eval_id,
+        configuration,
+        run_number: result.run_number,
+        result: {
+          pass_rate: result.pass_rate,
+          passed: result.passed,
+          failed: result.failed,
+          total: result.total,
+          time_seconds: result.time_seconds,
+          tokens: result.tokens,
+          tool_calls: result.tool_calls,
+          errors: result.errors,
+        },
+        expectations: result.expectations,
+        notes: result.notes,
+      });
+    }
+  }
+  const evalIds = [...new Set(runs.map((run) => run.eval_id))].sort((a, b) => a - b);
+  return {
+    metadata: {
+      skill_name: skillName || "<skill-name>",
+      skill_path: skillPath || "<path/to/skill>",
+      executor_model: "<model-name>",
+      analyzer_model: "<model-name>",
+      timestamp: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
+      evals_run: evalIds,
+      runs_per_configuration: 3,
+    },
+    runs,
+    run_summary: runSummary,
+    notes: [],
+  };
+}
+
+export function generateMarkdown(benchmark) {
+  const metadata = benchmark.metadata ?? {};
+  const runSummary = benchmark.run_summary ?? {};
+  const configs = Object.keys(runSummary).filter((key) => key !== "delta");
+  const configA = configs[0] ?? "config_a";
+  const configB = configs[1] ?? "config_b";
+  const aSummary = runSummary[configA] ?? {};
+  const bSummary = runSummary[configB] ?? {};
+  const delta = runSummary.delta ?? {};
+  const labelA = configA.replaceAll("_", " ").replace(/\b\w/g, (char) => char.toUpperCase());
+  const labelB = configB.replaceAll("_", " ").replace(/\b\w/g, (char) => char.toUpperCase());
+  const lines = [
+    `# Skill Benchmark: ${metadata.skill_name ?? "<skill-name>"}`,
+    "",
+    `**Model**: ${metadata.executor_model ?? "<model-name>"}`,
+    `**Date**: ${metadata.timestamp ?? ""}`,
+    `**Evals**: ${(metadata.evals_run ?? []).join(", ")} (${metadata.runs_per_configuration ?? 0} runs each per configuration)`,
+    "",
+    "## Summary",
+    "",
+    `| Metric | ${labelA} | ${labelB} | Delta |`,
+    "|--------|------------|---------------|-------|",
+    `| Pass Rate | ${(aSummary.pass_rate?.mean ?? 0) * 100}% ± ${(aSummary.pass_rate?.stddev ?? 0) * 100}% | ${(bSummary.pass_rate?.mean ?? 0) * 100}% ± ${(bSummary.pass_rate?.stddev ?? 0) * 100}% | ${delta.pass_rate ?? "—"} |`,
+    `| Time | ${(aSummary.time_seconds?.mean ?? 0).toFixed?.(1) ?? aSummary.time_seconds?.mean ?? 0}s ± ${(aSummary.time_seconds?.stddev ?? 0).toFixed?.(1) ?? aSummary.time_seconds?.stddev ?? 0}s | ${(bSummary.time_seconds?.mean ?? 0).toFixed?.(1) ?? bSummary.time_seconds?.mean ?? 0}s ± ${(bSummary.time_seconds?.stddev ?? 0).toFixed?.(1) ?? bSummary.time_seconds?.stddev ?? 0}s | ${delta.time_seconds ?? "—"}s |`,
+    `| Tokens | ${Math.round(aSummary.tokens?.mean ?? 0)} ± ${Math.round(aSummary.tokens?.stddev ?? 0)} | ${Math.round(bSummary.tokens?.mean ?? 0)} ± ${Math.round(bSummary.tokens?.stddev ?? 0)} | ${delta.tokens ?? "—"} |`,
+  ];
+  if (Array.isArray(benchmark.notes) && benchmark.notes.length > 0) {
+    lines.push("", "## Notes", "");
+    for (const note of benchmark.notes) {
+      lines.push(`- ${note}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+function parseArgs(args) {
+  const flags = { _: [] };
+  for (let i = 0; i < args.length; i += 1) {
+    const item = args[i];
+    if (!item.startsWith("-")) {
+      flags._.push(item);
+      continue;
+    }
+    const key = item.startsWith("--") ? item.slice(2) : item.slice(1);
+    const next = args[i + 1];
+    if (!next || next.startsWith("-")) {
+      flags[key] = true;
+      continue;
+    }
+    flags[key] = next;
+    i += 1;
+  }
+  return flags;
+}
+
+async function main(argv = process.argv) {
+  const args = parseArgs(argv.slice(2));
+  const benchmarkDir = args._[0];
+  if (!benchmarkDir) {
+    throw new Error("Usage: node aggregate_benchmark.mjs <benchmark_dir> [--skill-name name] [--skill-path path] [-o output.json]");
+  }
+  const outputJsonPath = path.resolve(args.output ?? args.o ?? path.join(benchmarkDir, "benchmark.json"));
+  const benchmark = await generateBenchmark(path.resolve(benchmarkDir), {
+    skillName: args["skill-name"] ?? "",
+    skillPath: args["skill-path"] ?? "",
+  });
+  await writeFile(outputJsonPath, `${JSON.stringify(benchmark, null, 2)}\n`);
+  await writeFile(outputJsonPath.replace(/\.json$/i, ".md"), `${generateMarkdown(benchmark)}\n`);
+  process.stdout.write(`Generated: ${outputJsonPath}\n`);
+  process.stdout.write(`Generated: ${outputJsonPath.replace(/\.json$/i, ".md")}\n`);
+}
+
+const entryPath = fileURLToPath(import.meta.url);
+if (process.argv[1] && path.resolve(process.argv[1]) === entryPath) {
+  main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+  });
+}

package/dist/builtin/skills/skill-creator/scripts/claude_cli.mjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+
+import { spawn, spawnSync } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+
+export function findProjectRoot(start = process.cwd()) {
+  const current = path.resolve(start);
+  let cursor = current;
+  while (true) {
+    if (path.basename(cursor) === ".claude" || existsDir(path.join(cursor, ".claude"))) {
+      return path.basename(cursor) === ".claude" ? path.dirname(cursor) : cursor;
+    }
+    const parent = path.dirname(cursor);
+    if (parent === cursor) {
+      return current;
+    }
+    cursor = parent;
+  }
+}
+
+function existsDir(dir) {
+  try {
+    return spawnSync("test", ["-d", dir]).status === 0;
+  } catch {
+    return false;
+  }
+}
+
+export function buildClaudeEnv() {
+  const env = { ...process.env };
+  delete env.CLAUDECODE;
+  return env;
+}
+
+export async function callClaudeText(prompt, { model, timeout = 300_000 } = {}) {
+  const args = ["-p", "--output-format", "text"];
+  if (model) args.push("--model", model);
+  return runClaude(args, { stdin: prompt, timeout });
+}
+
+export function runClaudeStream(args, { cwd, timeout = 30_000 } = {}) {
+  const child = spawn("claude", args, {
+    cwd,
+    env: buildClaudeEnv(),
+    stdio: ["ignore", "pipe", "ignore"],
+  });
+
+  const timer = setTimeout(() => {
+    child.kill("SIGKILL");
+  }, timeout);
+
+  child.once("exit", () => clearTimeout(timer));
+  child.once("error", () => clearTimeout(timer));
+  return child;
+}
+
+async function runClaude(args, { stdin, timeout = 300_000, cwd } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("claude", args, {
+      cwd,
+      env: buildClaudeEnv(),
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error(`claude -p timed out after ${Math.round(timeout / 1000)}s`));
+    }, timeout);
+
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code !== 0) {
+        reject(new Error(`claude -p exited ${code}\nstderr: ${stderr}`));
+        return;
+      }
+      resolve(stdout);
+    });
+
+    if (stdin) {
+      child.stdin.write(stdin);
+    }
+    child.stdin.end();
+  });
+}
+
+export function uuidFragment() {
+  return Math.random().toString(16).slice(2, 10) + Date.now().toString(16).slice(-4);
+}
+
+export function openInBrowser(target) {
+  const platform = os.platform();
+  if (platform === "darwin") {
+    spawn("open", [target], { detached: true, stdio: "ignore" }).unref();
+    return;
+  }
+  if (platform === "win32") {
+    spawn("cmd", ["/c", "start", "", target], { detached: true, stdio: "ignore" }).unref();
+    return;
+  }
+  spawn("xdg-open", [target], { detached: true, stdio: "ignore" }).unref();
+}