npm - @cydm/pie - Versions diffs - 1.0.6 → 1.0.8 - Mend

@cydm/pie 1.0.6 → 1.0.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (59) hide show

package/README.md +156 -9
package/dist/builtin/extensions/ask-user/index.js +2 -3
package/dist/builtin/extensions/init/index.js +70 -68
package/dist/builtin/extensions/kimi-attachments/index.js +3 -3
package/dist/builtin/extensions/plan-mode/index.js +85 -87
package/dist/builtin/extensions/subagent/index.js +17 -7
package/dist/builtin/extensions/todo/index.js +51 -22
package/dist/builtin/skills/browser-tools/CHANGELOG.md +2 -44
package/dist/builtin/skills/browser-tools/README.md +10 -99
package/dist/builtin/skills/browser-tools/SKILL.md +21 -174
package/dist/builtin/skills/browser-tools/package.json +6 -13
package/dist/builtin/skills/browser-tools/playwright-cli.js +24 -0
package/dist/builtin/skills/skill-creator/SKILL.md +17 -17
package/dist/builtin/skills/skill-creator/eval-viewer/generate_review.mjs +285 -0
package/dist/builtin/skills/skill-creator/eval-viewer/viewer.html +1 -1
package/dist/builtin/skills/skill-creator/scripts/aggregate_benchmark.mjs +271 -0
package/dist/builtin/skills/skill-creator/scripts/claude_cli.mjs +115 -0
package/dist/builtin/skills/skill-creator/scripts/generate_report.mjs +224 -0
package/dist/builtin/skills/skill-creator/scripts/improve_description.mjs +198 -0
package/dist/builtin/skills/skill-creator/scripts/package_skill.mjs +132 -0
package/dist/builtin/skills/skill-creator/scripts/pie_runner.mjs +115 -0
package/dist/builtin/skills/skill-creator/scripts/quick_validate.mjs +44 -0
package/dist/builtin/skills/skill-creator/scripts/run_eval.mjs +169 -0
package/dist/builtin/skills/skill-creator/scripts/run_loop.mjs +297 -0
package/dist/builtin/skills/skill-creator/scripts/skill_metadata.mjs +134 -0
package/dist/chunks/chunk-6WD2NFIC.js +8383 -0
package/dist/chunks/{chunk-MWFBYJOI.js → chunk-A5JSJAPK.js} +3973 -1313
package/dist/chunks/chunk-NTYHFBUA.js +36 -0
package/dist/chunks/chunk-ZRONUKTW.js +989 -0
package/dist/chunks/{src-EGWRDMLB.js → src-3X3HBT2G.js} +1 -2
package/dist/chunks/typescript-GSKWJIO4.js +210747 -0
package/dist/cli.js +15261 -12502
package/models.schema.json +238 -0
package/package.json +34 -8
package/dist/builtin/skills/browser-tools/browser-content.js +0 -103
package/dist/builtin/skills/browser-tools/browser-cookies.js +0 -35
package/dist/builtin/skills/browser-tools/browser-eval.js +0 -49
package/dist/builtin/skills/browser-tools/browser-hn-scraper.js +0 -108
package/dist/builtin/skills/browser-tools/browser-nav.js +0 -44
package/dist/builtin/skills/browser-tools/browser-pick.js +0 -162
package/dist/builtin/skills/browser-tools/browser-screenshot.js +0 -34
package/dist/builtin/skills/browser-tools/browser-start.js +0 -86
package/dist/builtin/skills/skill-creator/eval-viewer/generate_review.py +0 -471
package/dist/builtin/skills/skill-creator/scripts/__init__.py +0 -0
package/dist/builtin/skills/skill-creator/scripts/aggregate_benchmark.py +0 -401
package/dist/builtin/skills/skill-creator/scripts/generate_report.py +0 -326
package/dist/builtin/skills/skill-creator/scripts/improve_description.py +0 -247
package/dist/builtin/skills/skill-creator/scripts/package_skill.py +0 -136
package/dist/builtin/skills/skill-creator/scripts/quick_validate.py +0 -103
package/dist/builtin/skills/skill-creator/scripts/run_eval.py +0 -310
package/dist/builtin/skills/skill-creator/scripts/run_loop.py +0 -328
package/dist/builtin/skills/skill-creator/scripts/utils.py +0 -47
package/dist/chunks/capabilities-FENCOHVA.js +0 -9
package/dist/chunks/chunk-JYBXCEJJ.js +0 -315
package/dist/chunks/chunk-RID3574D.js +0 -2718
package/dist/chunks/chunk-TBJ25UWB.js +0 -3657
package/dist/chunks/chunk-XZXLO7YB.js +0 -322
package/dist/chunks/file-logger-AL5VVZHH.js +0 -22
package/dist/chunks/src-WRUACRN2.js +0 -132

package/dist/builtin/skills/skill-creator/scripts/generate_report.mjs ADDED Viewed

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { readFile, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+function escapeHtml(value) {
+  return String(value ?? "")
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;");
+}
+export function generateHtml(data, { autoRefresh = false, skillName = "" } = {}) {
+  const history = Array.isArray(data?.history) ? data.history : [];
+  const titlePrefix = skillName ? `${escapeHtml(skillName)} — ` : "";
+  const refreshTag = autoRefresh ? '    <meta http-equiv="refresh" content="5">\n' : "";
+  const trainQueries = [];
+  const testQueries = [];
+  if (history.length > 0) {
+    for (const result of history[0].train_results ?? history[0].results ?? []) {
+      trainQueries.push({ query: result.query, should_trigger: result.should_trigger ?? true });
+    }
+    for (const result of history[0].test_results ?? []) {
+      testQueries.push({ query: result.query, should_trigger: result.should_trigger ?? true });
+    }
+  }
+  let html = `<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+${refreshTag}    <title>${titlePrefix}Skill Description Optimization</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@500;600&family=Lora:wght@400;500&display=swap" rel="stylesheet">
+    <style>
+        body { font-family: 'Lora', Georgia, serif; max-width: 100%; margin: 0 auto; padding: 20px; background: #faf9f5; color: #141413; }
+        h1 { font-family: 'Poppins', sans-serif; color: #141413; }
+        .explainer, .summary { background: white; padding: 15px; border-radius: 6px; margin-bottom: 20px; border: 1px solid #e8e6dc; }
+        .explainer { color: #b0aea5; font-size: 0.875rem; line-height: 1.6; }
+        .summary p { margin: 5px 0; }
+        .best { color: #788c5d; font-weight: bold; }
+        .table-container { overflow-x: auto; width: 100%; }
+        table { border-collapse: collapse; background: white; border: 1px solid #e8e6dc; border-radius: 6px; font-size: 12px; min-width: 100%; }
+        th, td { padding: 8px; text-align: left; border: 1px solid #e8e6dc; white-space: normal; word-wrap: break-word; }
+        th { font-family: 'Poppins', sans-serif; background: #141413; color: #faf9f5; font-weight: 500; }
+        th.test-col { background: #6a9bcc; }
+        th.query-col { min-width: 200px; }
+        td.description { font-family: monospace; font-size: 11px; word-wrap: break-word; max-width: 400px; }
+        td.result { text-align: center; font-size: 16px; min-width: 40px; }
+        td.test-result { background: #f0f6fc; }
+        .pass { color: #788c5d; }
+        .fail { color: #c44; }
+        .rate { font-size: 9px; color: #b0aea5; display: block; }
+        tr:hover { background: #faf9f5; }
+        .score { display: inline-block; padding: 2px 6px; border-radius: 4px; font-weight: bold; font-size: 11px; }
+        .score-good { background: #eef2e8; color: #788c5d; }
+        .score-ok { background: #fef3c7; color: #d97706; }
+        .score-bad { background: #fceaea; color: #c44; }
+        .best-row { background: #f5f8f2; }
+        th.positive-col { border-bottom: 3px solid #788c5d; }
+        th.negative-col { border-bottom: 3px solid #c44; }
+        .legend { font-family: 'Poppins', sans-serif; display: flex; gap: 20px; margin-bottom: 10px; font-size: 13px; align-items: center; }
+        .legend-item { display: flex; align-items: center; gap: 6px; }
+        .legend-swatch { width: 16px; height: 16px; border-radius: 3px; display: inline-block; }
+        .swatch-positive { background: #141413; border-bottom: 3px solid #788c5d; }
+        .swatch-negative { background: #141413; border-bottom: 3px solid #c44; }
+        .swatch-test { background: #6a9bcc; }
+        .swatch-train { background: #141413; }
+    </style>
+</head>
+<body>
+    <h1>${titlePrefix}Skill Description Optimization</h1>
+    <div class="explainer">
+        <strong>Optimizing your skill's description.</strong> This page updates automatically as Claude tests different versions of your skill's description. Each row is an iteration — a new description attempt. The columns show test queries: green checkmarks mean the skill triggered correctly (or correctly didn't trigger), red crosses mean it got it wrong.
+    </div>
+    <div class="summary">
+        <p><strong>Original:</strong> ${escapeHtml(data?.original_description ?? "N/A")}</p>
+        <p class="best"><strong>Best:</strong> ${escapeHtml(data?.best_description ?? "N/A")}</p>
+        <p><strong>Best Score:</strong> ${escapeHtml(data?.best_score ?? "N/A")}</p>
+        <p><strong>Iterations:</strong> ${escapeHtml(data?.iterations_run ?? 0)} | <strong>Train:</strong> ${escapeHtml(data?.train_size ?? "?")} | <strong>Test:</strong> ${escapeHtml(data?.test_size ?? "?")}</p>
+    </div>
+    <div class="legend">
+        <span style="font-weight:600">Query columns:</span>
+        <span class="legend-item"><span class="legend-swatch swatch-positive"></span> Should trigger</span>
+        <span class="legend-item"><span class="legend-swatch swatch-negative"></span> Should NOT trigger</span>
+        <span class="legend-item"><span class="legend-swatch swatch-train"></span> Train</span>
+        <span class="legend-item"><span class="legend-swatch swatch-test"></span> Test</span>
+    </div>
+    <div class="table-container">
+    <table>
+        <thead>
+            <tr>
+                <th>Iter</th>
+                <th>Train</th>
+                <th>Test</th>
+                <th class="query-col">Description</th>
+`;
+  for (const info of trainQueries) {
+    html += `                <th class="${info.should_trigger ? "positive-col" : "negative-col"}">${escapeHtml(info.query)}</th>\n`;
+  }
+  for (const info of testQueries) {
+    html += `                <th class="test-col ${info.should_trigger ? "positive-col" : "negative-col"}">${escapeHtml(info.query)}</th>\n`;
+  }
+  html += `            </tr>
+        </thead>
+        <tbody>
+`;
+  const bestIteration = history.length === 0
+    ? null
+    : testQueries.length > 0
+      ? history.reduce((best, item) => (item.test_passed ?? -1) > (best?.test_passed ?? -1) ? item : best, null)?.iteration
+      : history.reduce((best, item) => (item.train_passed ?? item.passed ?? -1) > (best?.train_passed ?? best?.passed ?? -1) ? item : best, null)?.iteration;
+  for (const item of history) {
+    const trainResults = item.train_results ?? item.results ?? [];
+    const testResults = item.test_results ?? [];
+    const trainByQuery = new Map(trainResults.map((entry) => [entry.query, entry]));
+    const testByQuery = new Map(testResults.map((entry) => [entry.query, entry]));
+    const aggregateRuns = (results) => {
+      let correct = 0;
+      let total = 0;
+      for (const result of results) {
+        const runs = result.runs ?? 0;
+        const triggers = result.triggers ?? 0;
+        total += runs;
+        correct += result.should_trigger ? triggers : runs - triggers;
+      }
+      return { correct, total };
+    };
+    const trainAgg = aggregateRuns(trainResults);
+    const testAgg = aggregateRuns(testResults);
+    const scoreClass = ({ correct, total }) => {
+      const ratio = total > 0 ? correct / total : 0;
+      if (ratio >= 0.8) return "score-good";
+      if (ratio >= 0.5) return "score-ok";
+      return "score-bad";
+    };
+    html += `            <tr class="${item.iteration === bestIteration ? "best-row" : ""}">
+                <td>${escapeHtml(item.iteration)}</td>
+                <td><span class="score ${scoreClass(trainAgg)}">${trainAgg.correct}/${trainAgg.total}</span></td>
+                <td><span class="score ${scoreClass(testAgg)}">${testAgg.correct}/${testAgg.total}</span></td>
+                <td class="description">${escapeHtml(item.description ?? "")}</td>
+`;
+    for (const info of trainQueries) {
+      const result = trainByQuery.get(info.query) ?? {};
+      html += `                <td class="result ${result.pass ? "pass" : "fail"}">${result.pass ? "✓" : "✗"}<span class="rate">${result.triggers ?? 0}/${result.runs ?? 0}</span></td>\n`;
+    }
+    for (const info of testQueries) {
+      const result = testByQuery.get(info.query) ?? {};
+      html += `                <td class="result test-result ${result.pass ? "pass" : "fail"}">${result.pass ? "✓" : "✗"}<span class="rate">${result.triggers ?? 0}/${result.runs ?? 0}</span></td>\n`;
+    }
+    html += "            </tr>\n";
+  }
+  html += `        </tbody>
+    </table>
+    </div>
+</body>
+</html>
+`;
+  return html;
+}
+async function main(argv = process.argv) {
+  const args = parseArgs(argv.slice(2));
+  const inputPath = args._[0];
+  if (!inputPath) {
+    throw new Error("Usage: node generate_report.mjs <input.json> [-o output.html] [--skill-name name]");
+  }
+  const raw = inputPath === "-" ? await readStdin() : await readFile(inputPath, "utf8");
+  const data = JSON.parse(raw);
+  const output = generateHtml(data, { skillName: args["skill-name"] ?? "", autoRefresh: false });
+  if (args.output || args.o) {
+    await writeFile(args.output || args.o, output);
+    process.stderr.write(`Report written to ${args.output || args.o}\n`);
+    return;
+  }
+  process.stdout.write(output);
+}
+function parseArgs(args) {
+  const out = { _: [] };
+  for (let i = 0; i < args.length; i += 1) {
+    const item = args[i];
+    if (!item.startsWith("-")) {
+      out._.push(item);
+      continue;
+    }
+    const key = item.startsWith("--") ? item.slice(2) : item.slice(1);
+    const next = args[i + 1];
+    if (!next || next.startsWith("-")) {
+      out[key] = true;
+      continue;
+    }
+    out[key] = next;
+    i += 1;
+  }
+  return out;
+}
+async function readStdin() {
+  let data = "";
+  for await (const chunk of process.stdin) {
+    data += String(chunk);
+  }
+  return data;
+}
+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/improve_description.mjs ADDED Viewed

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { callPieText } from "./pie_runner.mjs";
+import { parseSkillFile } from "./skill_metadata.mjs";
+export async function improveDescription({
+  skillName,
+  skillContent,
+  currentDescription,
+  evalResults,
+  history,
+  model,
+  testResults = null,
+  logDir = null,
+  iteration = null,
+}) {
+  const failedTriggers = evalResults.results.filter((r) => r.should_trigger && !r.pass);
+  const falseTriggers = evalResults.results.filter((r) => !r.should_trigger && !r.pass);
+  const trainScore = `${evalResults.summary.passed}/${evalResults.summary.total}`;
+  const scoresSummary = testResults
+    ? `Train: ${trainScore}, Test: ${testResults.summary.passed}/${testResults.summary.total}`
+    : `Train: ${trainScore}`;
+  let prompt = `You are optimizing a skill description for a Claude Code skill called "${skillName}". A "skill" is sort of like a prompt, but with progressive disclosure -- there's a title and description that Claude sees when deciding whether to use the skill, and then if it does use the skill, it reads the .md file which has lots more details and potentially links to other resources in the skill folder like helper files and scripts and additional documentation or examples.
+The description appears in Claude's "available_skills" list. When a user sends a query, Claude decides whether to invoke the skill based solely on the title and on this description. Your goal is to write a description that triggers for relevant queries, and doesn't trigger for irrelevant ones.
+Here's the current description:
+<current_description>
+"${currentDescription}"
+</current_description>
+Current scores (${scoresSummary}):
+<scores_summary>
+`;
+  if (failedTriggers.length > 0) {
+    prompt += "FAILED TO TRIGGER (should have triggered but didn't):\n";
+    for (const result of failedTriggers) {
+      prompt += `  - "${result.query}" (triggered ${result.triggers}/${result.runs} times)\n`;
+    }
+    prompt += "\n";
+  }
+  if (falseTriggers.length > 0) {
+    prompt += "FALSE TRIGGERS (triggered but shouldn't have):\n";
+    for (const result of falseTriggers) {
+      prompt += `  - "${result.query}" (triggered ${result.triggers}/${result.runs} times)\n`;
+    }
+    prompt += "\n";
+  }
+  if (history.length > 0) {
+    prompt += "PREVIOUS ATTEMPTS (do NOT repeat these — try something structurally different):\n\n";
+    for (const item of history) {
+      const trainScoreText = `${item.train_passed ?? item.passed ?? 0}/${item.train_total ?? item.total ?? 0}`;
+      const testScoreText = item.test_passed !== undefined && item.test_passed !== null
+        ? `${item.test_passed}/${item.test_total}`
+        : null;
+      prompt += `<attempt train=${trainScoreText}${testScoreText ? `, test=${testScoreText}` : ""}>\n`;
+      prompt += `Description: "${item.description}"\n`;
+      if (Array.isArray(item.results)) {
+        prompt += "Train results:\n";
+        for (const result of item.results) {
+          prompt += `  [${result.pass ? "PASS" : "FAIL"}] "${String(result.query).slice(0, 80)}" (triggered ${result.triggers}/${result.runs})\n`;
+        }
+      }
+      if (item.note) {
+        prompt += `Note: ${item.note}\n`;
+      }
+      prompt += "</attempt>\n\n";
+    }
+  }
+  prompt += `</scores_summary>
+Skill content (for context on what the skill does):
+<skill_content>
+${skillContent}
+</skill_content>
+Based on the failures, write a new and improved description that is more likely to trigger correctly. When I say "based on the failures", it's a bit of a tricky line to walk because we don't want to overfit to the specific cases you're seeing. So what I DON'T want you to do is produce an ever-expanding list of specific queries that this skill should or shouldn't trigger for. Instead, try to generalize from the failures to broader categories of user intent and situations where this skill would be useful or not useful. The reason for this is twofold:
+1. Avoid overfitting
+2. The list might get loooong and it's injected into ALL queries and there might be a lot of skills, so we don't want to blow too much space on any given description.
+Concretely, your description should not be more than about 100-200 words, even if that comes at the cost of accuracy. There is a hard limit of 1024 characters — descriptions over that will be truncated, so stay comfortably under it.
+Here are some tips that we've found to work well in writing these descriptions:
+- The skill should be phrased in the imperative -- "Use this skill for" rather than "this skill does"
+- The skill description should focus on the user's intent, what they are trying to achieve, vs. the implementation details of how the skill works.
+- The description competes with other skills for Claude's attention — make it distinctive and immediately recognizable.
+- If you're getting lots of failures after repeated attempts, change things up. Try different sentence structures or wordings.
+I'd encourage you to be creative and mix up the style in different iterations since you'll have multiple opportunities to try different approaches and we'll just grab the highest-scoring one at the end.
+Please respond with only the new description text in <new_description> tags, nothing else.`;
+  const transcript = { iteration, prompt };
+  const text = await callPieText(prompt);
+  transcript.response = text;
+  let description = parseDescription(text);
+  transcript.parsed_description = description;
+  transcript.char_count = description.length;
+  transcript.over_limit = description.length > 1024;
+  if (description.length > 1024) {
+    const shortenPrompt = `${prompt}
+---
+A previous attempt produced this description, which at ${description.length} characters is over the 1024-character hard limit:
+"${description}"
+Rewrite it to be under 1024 characters while keeping the most important trigger words and intent coverage. Respond with only the new description in <new_description> tags.`;
+    const shortenText = await callPieText(shortenPrompt);
+    const shortened = parseDescription(shortenText);
+    transcript.rewrite_prompt = shortenPrompt;
+    transcript.rewrite_response = shortenText;
+    transcript.rewrite_description = shortened;
+    transcript.rewrite_char_count = shortened.length;
+    description = shortened;
+  }
+  transcript.final_description = description;
+  if (logDir) {
+    await mkdir(logDir, { recursive: true });
+    await writeFile(path.join(logDir, `improve_iter_${iteration ?? "unknown"}.json`), JSON.stringify(transcript, null, 2));
+  }
+  return description;
+}
+function parseDescription(text) {
+  const match = text.match(/<new_description>([\s\S]*?)<\/new_description>/);
+  return (match ? match[1] : text).trim().replace(/^"(.*)"$/s, "$1");
+}
+async function main(argv = process.argv) {
+  const args = parseArgs(argv.slice(2));
+  const skillPath = path.resolve(args["skill-path"]);
+  const evalResults = JSON.parse(await readFile(args["eval-results"], "utf8"));
+  const history = args.history ? JSON.parse(await readFile(args.history, "utf8")) : [];
+  const { name, content } = await parseSkillFile(skillPath);
+  const currentDescription = evalResults.description;
+  const description = await improveDescription({
+    skillName: name,
+    skillContent: content,
+    currentDescription,
+    evalResults,
+    history,
+    model: args.model,
+  });
+  const output = {
+    description,
+    history: history.concat([{
+      description: currentDescription,
+      passed: evalResults.summary.passed,
+      failed: evalResults.summary.failed,
+      total: evalResults.summary.total,
+      results: evalResults.results,
+    }]),
+  };
+  process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+}
+function parseArgs(args) {
+  const flags = {};
+  for (let i = 0; i < args.length; i += 1) {
+    const value = args[i];
+    if (!value.startsWith("--")) continue;
+    const key = value.slice(2);
+    const next = args[i + 1];
+    if (!next || next.startsWith("--")) {
+      flags[key] = true;
+      continue;
+    }
+    flags[key] = next;
+    i += 1;
+  }
+  return flags;
+}
+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/package_skill.mjs ADDED Viewed

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import JSZip from "jszip";
+import { validateSkill } from "./quick_validate.mjs";
+const EXCLUDE_DIRS = new Set(["__pycache__", "node_modules"]);
+const EXCLUDE_GLOBS = [/\.pyc$/i];
+const EXCLUDE_FILES = new Set([".DS_Store"]);
+const ROOT_EXCLUDE_DIRS = new Set(["evals"]);
+function shouldExclude(relPath) {
+  const parts = relPath.split("/").filter(Boolean);
+  if (parts.some((part) => EXCLUDE_DIRS.has(part))) {
+    return true;
+  }
+  if (parts.length > 1 && ROOT_EXCLUDE_DIRS.has(parts[1])) {
+    return true;
+  }
+  const name = parts[parts.length - 1] || "";
+  if (EXCLUDE_FILES.has(name)) {
+    return true;
+  }
+  return EXCLUDE_GLOBS.some((pattern) => pattern.test(name));
+}
+async function collectFiles(dir, baseDir, acc = []) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await collectFiles(fullPath, baseDir, acc);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    acc.push({
+      fullPath,
+      arcname: path.relative(baseDir, fullPath).replace(/\\/g, "/"),
+    });
+  }
+  return acc;
+}
+export async function packageSkill(skillPath, outputDir) {
+  const resolvedSkillPath = path.resolve(skillPath);
+  const skillStats = await stat(resolvedSkillPath).catch(() => null);
+  if (!skillStats) {
+    process.stdout.write(`❌ Error: Skill folder not found: ${resolvedSkillPath}\n`);
+    return null;
+  }
+  if (!skillStats.isDirectory()) {
+    process.stdout.write(`❌ Error: Path is not a directory: ${resolvedSkillPath}\n`);
+    return null;
+  }
+  const skillMdPath = path.join(resolvedSkillPath, "SKILL.md");
+  const skillMdStats = await stat(skillMdPath).catch(() => null);
+  if (!skillMdStats || !skillMdStats.isFile()) {
+    process.stdout.write(`❌ Error: SKILL.md not found in ${resolvedSkillPath}\n`);
+    return null;
+  }
+  process.stdout.write("🔍 Validating skill...\n");
+  const validation = await validateSkill(resolvedSkillPath);
+  if (!validation.valid) {
+    process.stdout.write(`❌ Validation failed: ${validation.message}\n`);
+    process.stdout.write("   Please fix the validation errors before packaging.\n");
+    return null;
+  }
+  process.stdout.write(`✅ ${validation.message}\n\n`);
+  const outputPath = outputDir ? path.resolve(outputDir) : process.cwd();
+  await mkdir(outputPath, { recursive: true });
+  const skillName = path.basename(resolvedSkillPath);
+  const archivePath = path.join(outputPath, `${skillName}.skill`);
+  const zip = new JSZip();
+  const baseDir = path.dirname(resolvedSkillPath);
+  const files = await collectFiles(resolvedSkillPath, baseDir);
+  for (const file of files) {
+    if (shouldExclude(file.arcname)) {
+      process.stdout.write(`  Skipped: ${file.arcname}\n`);
+      continue;
+    }
+    zip.file(file.arcname, await readFile(file.fullPath));
+    process.stdout.write(`  Added: ${file.arcname}\n`);
+  }
+  const buffer = await zip.generateAsync({
+    type: "nodebuffer",
+    compression: "DEFLATE",
+    compressionOptions: { level: 9 },
+  });
+  await writeFile(archivePath, buffer);
+  process.stdout.write(`\n✅ Successfully packaged skill to: ${archivePath}\n`);
+  return archivePath;
+}
+async function main(argv = process.argv) {
+  if (argv.length < 3) {
+    process.stdout.write("Usage: node package_skill.mjs <path/to/skill-folder> [output-directory]\n");
+    process.stdout.write("\nExample:\n");
+    process.stdout.write("  node package_skill.mjs skills/public/my-skill\n");
+    process.stdout.write("  node package_skill.mjs skills/public/my-skill ./dist\n");
+    process.exitCode = 1;
+    return;
+  }
+  const skillPath = argv[2];
+  const outputDir = argv[3];
+  process.stdout.write(`📦 Packaging skill: ${skillPath}\n`);
+  if (outputDir) {
+    process.stdout.write(`   Output directory: ${outputDir}\n`);
+  }
+  process.stdout.write("\n");
+  const result = await packageSkill(skillPath, outputDir);
+  process.exitCode = result ? 0 : 1;
+}
+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/pie_runner.mjs ADDED Viewed

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+import crypto from "node:crypto";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(SCRIPT_DIR, "../../../../../../");
+export function findProjectRoot(start = process.cwd()) {
+  return path.resolve(start);
+}
+export function uuidFragment() {
+  return crypto.randomBytes(4).toString("hex");
+}
+export function openInBrowser(target) {
+  const platform = process.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();
+}
+function getPieCliPath(cwd = process.cwd()) {
+  return path.join(REPO_ROOT, "products/cli/dist/cli.js");
+}
+export async function runPieJsonPrompt(prompt, { cwd = process.cwd(), timeout = 300_000, sessionId = null } = {}) {
+  return new Promise((resolve, reject) => {
+    const args = [getPieCliPath(cwd), prompt, "--json-output"];
+    if (sessionId) {
+      args.push("--session-id", sessionId);
+    }
+    const child = spawn("node", args, {
+      cwd,
+      env: { ...process.env },
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const cleanup = () => {
+      clearTimeout(timer);
+      child.stdout.removeAllListeners();
+      child.stderr.removeAllListeners();
+      child.removeAllListeners();
+    };
+    const finish = (cb) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      try {
+        child.kill("SIGKILL");
+      } catch {}
+      cb();
+    };
+    const tryResolveFromStdout = () => {
+      const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+      for (let i = lines.length - 1; i >= 0; i -= 1) {
+        const line = lines[i];
+        if (!line.startsWith("{")) continue;
+        try {
+          const parsed = JSON.parse(line);
+          if (Object.prototype.hasOwnProperty.call(parsed, "ok")) {
+            finish(() => resolve(parsed));
+            return true;
+          }
+        } catch {}
+      }
+      return false;
+    };
+    const timer = setTimeout(() => {
+      finish(() => reject(new Error(`pie prompt timed out after ${Math.round(timeout / 1000)}s`)));
+    }, timeout);
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+      tryResolveFromStdout();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => {
+      finish(() => reject(error));
+    });
+    child.on("close", (code) => {
+      if (tryResolveFromStdout()) {
+        return;
+      }
+      finish(() => reject(new Error(`pie prompt exited ${code}\nstdout: ${stdout}\nstderr: ${stderr}`)));
+    });
+  });
+}
+export async function callPieText(prompt, { cwd = process.cwd(), timeout = 300_000, sessionId = null } = {}) {
+  const response = await runPieJsonPrompt(prompt, { cwd, timeout, sessionId });
+  if (!response?.ok) {
+    throw new Error(response?.error || "Pie prompt failed");
+  }
+  return String(response.text || "");
+}