squad-kit 0.1.0

package/dist/cli.js

@@ -0,0 +1,607 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import kleur7 from "kleur";
+
+// src/commands/init.ts
+import fs4 from "fs";
+import path3 from "path";
+import kleur from "kleur";
+import { input, select, checkbox, confirm } from "@inquirer/prompts";
+
+// src/core/paths.ts
+import path from "path";
+import fs from "fs";
+var SQUAD_DIR = ".squad";
+function buildPaths(root) {
+  const squadDir = path.join(root, SQUAD_DIR);
+  return {
+    root,
+    squadDir,
+    configFile: path.join(squadDir, "config.yaml"),
+    promptsDir: path.join(squadDir, "prompts"),
+    storiesDir: path.join(squadDir, "stories"),
+    plansDir: path.join(squadDir, "plans"),
+    indexFile: path.join(squadDir, "plans", "00-index.md")
+  };
+}
+function findSquadRoot(startDir = process.cwd()) {
+  let current = path.resolve(startDir);
+  const { root } = path.parse(current);
+  while (true) {
+    if (fs.existsSync(path.join(current, SQUAD_DIR, "config.yaml"))) {
+      return current;
+    }
+    if (current === root) return null;
+    current = path.dirname(current);
+  }
+}
+function requireSquadRoot(startDir = process.cwd()) {
+  const root = findSquadRoot(startDir);
+  if (!root) {
+    throw new Error(
+      `No .squad/ directory found (searched upward from ${startDir}). Run \`squad init\` first.`
+    );
+  }
+  return root;
+}
+function slugify(input3) {
+  return input3.toLowerCase().trim().replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+}
+
+// src/core/config.ts
+import fs2 from "fs";
+import yaml from "js-yaml";
+var DEFAULT_CONFIG = {
+  version: 1,
+  project: {
+    name: "my-project",
+    primaryLanguage: "typescript",
+    projectRoots: ["."]
+  },
+  tracker: { type: "none" },
+  naming: { includeTrackerId: false, globalSequence: true },
+  agents: []
+};
+function loadConfig(configFile) {
+  const raw = fs2.readFileSync(configFile, "utf8");
+  const parsed = yaml.load(raw);
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error(`Invalid config at ${configFile}: expected a YAML object.`);
+  }
+  return mergeConfig(DEFAULT_CONFIG, parsed);
+}
+function saveConfig(configFile, config) {
+  const body = yaml.dump(config, { lineWidth: 100, noRefs: true, sortKeys: false });
+  fs2.writeFileSync(configFile, body, "utf8");
+}
+function mergeConfig(base, override) {
+  return {
+    version: override.version ?? base.version,
+    project: { ...base.project, ...override.project ?? {} },
+    tracker: { ...base.tracker, ...override.tracker ?? {} },
+    naming: { ...base.naming, ...override.naming ?? {} },
+    agents: override.agents ?? base.agents
+  };
+}
+
+// src/utils/fs.ts
+import fs3 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+function readFile(file) {
+  return fs3.readFileSync(file, "utf8");
+}
+function writeFileSafe(file, content, overwrite = false) {
+  if (!overwrite && fs3.existsSync(file)) return false;
+  fs3.mkdirSync(path2.dirname(file), { recursive: true });
+  fs3.writeFileSync(file, content, "utf8");
+  return true;
+}
+function copyTree(srcDir, destDir, overwrite = false) {
+  fs3.mkdirSync(destDir, { recursive: true });
+  for (const entry of fs3.readdirSync(srcDir, { withFileTypes: true })) {
+    const src = path2.join(srcDir, entry.name);
+    const dest = path2.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      copyTree(src, dest, overwrite);
+    } else if (entry.isFile()) {
+      if (!overwrite && fs3.existsSync(dest)) continue;
+      fs3.copyFileSync(src, dest);
+    }
+  }
+}
+function packageRoot() {
+  const here = path2.dirname(fileURLToPath(import.meta.url));
+  let dir = here;
+  for (let i = 0; i < 6; i++) {
+    if (fs3.existsSync(path2.join(dir, "package.json")) && fs3.existsSync(path2.join(dir, "templates"))) {
+      return dir;
+    }
+    dir = path2.dirname(dir);
+  }
+  throw new Error(`Could not locate squad-kit package root from ${here}`);
+}
+function templatesDir() {
+  return path2.join(packageRoot(), "templates");
+}
+
+// src/core/template.ts
+var TOKEN = /\{\{\s*([\w.-]+)\s*\}\}/g;
+function render(template, vars) {
+  return template.replace(TOKEN, (_, key) => {
+    const value = vars[key];
+    return value === void 0 || value === null ? "" : String(value);
+  });
+}
+
+// src/commands/init.ts
+var SUPPORTED_AGENTS = ["claude-code", "cursor", "copilot", "gemini"];
+var AGENT_INSTALL = {
+  "claude-code": { subdir: path3.join(".claude", "commands"), srcDir: "claude-code" },
+  cursor: { subdir: path3.join(".cursor", "commands"), srcDir: "cursor" },
+  copilot: { subdir: path3.join(".github", "prompts"), srcDir: "copilot" },
+  gemini: { subdir: path3.join(".gemini", "commands"), srcDir: "gemini" }
+};
+async function runInit(opts) {
+  const root = process.cwd();
+  const paths = buildPaths(root);
+  if (fs4.existsSync(paths.configFile) && !opts.force) {
+    console.log(kleur.yellow(`A ${SQUAD_DIR}/config.yaml already exists.`));
+    console.log(`  To add agents or change settings, re-run with ${kleur.bold("--force")} or edit the file directly.`);
+    return;
+  }
+  const defaults = {
+    name: opts.name ?? path3.basename(root),
+    language: opts.language ?? "typescript",
+    tracker: opts.tracker ?? "none",
+    agents: parseAgentsFlag(opts.agents)
+  };
+  const answers = opts.yes ? defaults : {
+    name: await input({ message: "Project name", default: defaults.name }),
+    language: await input({ message: "Primary language", default: defaults.language }),
+    tracker: await select({
+      message: "Issue tracker",
+      choices: [
+        { name: "None", value: "none" },
+        { name: "GitHub Issues", value: "github" },
+        { name: "Linear", value: "linear" },
+        { name: "Jira", value: "jira" },
+        { name: "Azure DevOps", value: "azure" }
+      ],
+      default: defaults.tracker
+    }),
+    agents: await checkbox({
+      message: "Install slash commands for which agents?",
+      choices: SUPPORTED_AGENTS.map((a) => ({ name: a, value: a, checked: defaults.agents.includes(a) }))
+    })
+  };
+  const includeTrackerId = answers.tracker !== "none" ? await confirmSafe("Include tracker id in plan filenames (NN-story-<slug>-<id>.md)?", true, !!opts.yes) : false;
+  const config = {
+    version: 1,
+    project: { name: answers.name, primaryLanguage: answers.language, projectRoots: ["."] },
+    tracker: { type: answers.tracker },
+    naming: { includeTrackerId, globalSequence: true },
+    agents: answers.agents
+  };
+  fs4.mkdirSync(paths.squadDir, { recursive: true });
+  fs4.mkdirSync(paths.promptsDir, { recursive: true });
+  fs4.mkdirSync(paths.storiesDir, { recursive: true });
+  fs4.mkdirSync(paths.plansDir, { recursive: true });
+  copyTree(path3.join(templatesDir(), "prompts"), paths.promptsDir, !!opts.force);
+  writeFileSafe(
+    paths.indexFile,
+    readFile(path3.join(templatesDir(), "index.md")),
+    !!opts.force
+  );
+  saveConfig(paths.configFile, config);
+  writeFileSafe(
+    path3.join(paths.squadDir, "README.md"),
+    renderSquadReadme(config),
+    !!opts.force
+  );
+  for (const agent of answers.agents) {
+    installAgent(root, agent, !!opts.force);
+  }
+  console.log(kleur.green(`
+\u2713 Initialized ${SQUAD_DIR}/ at ${root}`));
+  console.log(`  tracker: ${config.tracker.type}`);
+  console.log(`  agents:  ${answers.agents.length ? answers.agents.join(", ") : "(none)"}`);
+  console.log(`
+Next:`);
+  console.log(`  1) ${kleur.bold("squad new-story <feature-slug>")}`);
+  console.log(`  2) Fill the generated intake.md, then run ${kleur.bold("/squad-plan")} in your agent (or ${kleur.bold("squad new-plan")}).`);
+}
+function parseAgentsFlag(flag) {
+  if (!flag) return [];
+  return flag.split(",").map((s) => s.trim()).filter((s) => SUPPORTED_AGENTS.includes(s));
+}
+async function confirmSafe(message, defaultValue, nonInteractive) {
+  if (nonInteractive) return defaultValue;
+  return confirm({ message, default: defaultValue });
+}
+function installAgent(root, agent, overwrite) {
+  const config = AGENT_INSTALL[agent];
+  const src = path3.join(templatesDir(), "agents", config.srcDir);
+  const dest = path3.join(root, config.subdir);
+  if (!fs4.existsSync(src)) return;
+  copyTree(src, dest, overwrite);
+}
+function renderSquadReadme(config) {
+  return render(
+    `# squad-kit workspace
+
+This folder is managed by [squad-kit](https://github.com/AzmSquad/squad-kit).
+
+- **Project:** {{name}}
+- **Language:** {{language}}
+- **Tracker:** {{tracker}}
+
+## Workflow
+
+1. **Intake** \u2014 \`squad new-story <feature-slug>\` scaffolds \`stories/<feature>/<id>/intake.md\`. Paste the tracker title, description, and acceptance criteria.
+2. **Plan** \u2014 Run \`/squad-plan <intake-path>\` in your agent (or \`squad new-plan <intake-path>\` to get the composed prompt on stdout).
+3. **Implement** \u2014 Open a new, scoped agent session and attach **only** the generated \`NN-story-*.md\` file. Let a cheap model execute it.
+
+See \`prompts/generate-plan.md\` for the plan-generation meta-prompt and \`prompts/story-skeleton.md\` for the target plan structure.
+`,
+    { name: config.project.name, language: config.project.primaryLanguage ?? "", tracker: config.tracker.type }
+  );
+}
+
+// src/commands/new-story.ts
+import fs5 from "fs";
+import path4 from "path";
+import kleur2 from "kleur";
+import { input as input2 } from "@inquirer/prompts";
+
+// src/core/tracker.ts
+var VALIDATORS = {
+  github: /^(?:[\w.-]+\/[\w.-]+#)?\d+$/,
+  linear: /^[A-Z][A-Z0-9]+-\d+$/i,
+  jira: /^[A-Z][A-Z0-9]+-\d+$/,
+  azure: /^\d+$/
+};
+function validateTrackerId(type, id) {
+  if (type === "none") return true;
+  const pattern = VALIDATORS[type];
+  return pattern.test(id);
+}
+function trackerIdForFilename(type, id) {
+  if (type === "github") return id.replace(/^[\w.-]+\/[\w.-]+#/, "");
+  return id;
+}
+
+// src/commands/new-story.ts
+async function runNewStory(featureSlug, opts) {
+  if (!featureSlug) {
+    throw new Error('feature-slug is required. Usage: squad new-story <feature-slug> [--id <tracker-id>] [--title "..."]');
+  }
+  const slug = slugify(featureSlug);
+  if (!slug) throw new Error(`Invalid feature slug: "${featureSlug}"`);
+  const root = requireSquadRoot();
+  const paths = buildPaths(root);
+  const config = loadConfig(paths.configFile);
+  const interactive = !opts.yes && Boolean(process.stdin.isTTY);
+  const trackerNeedsId = config.tracker.type !== "none" && config.naming.includeTrackerId;
+  let id = opts.id;
+  let title = opts.title;
+  if (!id && trackerNeedsId) {
+    if (!interactive) {
+      throw new Error(
+        `Tracker "${config.tracker.type}" is configured and naming.includeTrackerId is true. Pass --id <tracker-id>.`
+      );
+    }
+    id = await input2({
+      message: `${config.tracker.type} work-item id:`,
+      validate: (v) => validateTrackerId(config.tracker.type, v.trim()) ? true : `Invalid ${config.tracker.type} id format.`
+    });
+    id = id.trim();
+  }
+  if (id && !validateTrackerId(config.tracker.type, id)) {
+    throw new Error(
+      `Invalid tracker id "${id}" for tracker type "${config.tracker.type}". Check .squad/config.yaml or pass --id in the right format.`
+    );
+  }
+  if (!id && !title) {
+    if (!interactive) {
+      throw new Error('Provide either --id <tracker-id> or --title "..." so the story folder has a distinct name.');
+    }
+    title = (await input2({ message: "Short story title:" })).trim();
+    if (!title) throw new Error("Title cannot be empty.");
+  }
+  if (interactive && !title) {
+    const maybe = (await input2({ message: "Short title (optional, press Enter to skip):", default: "" })).trim();
+    if (maybe) title = maybe;
+  }
+  const storyFolderName = id ? trackerIdForFilename(config.tracker.type, id) : slugify(title);
+  if (!storyFolderName) throw new Error("Could not derive a story folder name from --id or --title.");
+  const storyDir = path4.join(paths.storiesDir, slug, storyFolderName);
+  const intakeFile = path4.join(storyDir, "intake.md");
+  const attachmentsDir = path4.join(storyDir, "attachments");
+  if (fs5.existsSync(intakeFile)) {
+    throw new Error(`Intake already exists: ${intakeFile}`);
+  }
+  fs5.mkdirSync(attachmentsDir, { recursive: true });
+  const template = readFile(path4.join(templatesDir(), "prompts", "intake.md"));
+  const rendered = render(template, {
+    featureSlug: slug,
+    storyId: storyFolderName,
+    trackerType: config.tracker.type,
+    projectRoots: (config.project.projectRoots ?? ["."]).join(", "),
+    primaryLanguage: config.project.primaryLanguage ?? ""
+  });
+  const preamble = title ? `> **Title hint (from CLI):** ${title}
+
+` : "";
+  writeFileSafe(intakeFile, preamble + rendered, false);
+  ensureFeatureOverview(path4.join(paths.plansDir, slug), slug);
+  console.log(kleur2.green(`\u2713 Created intake:`));
+  console.log(`  ${path4.relative(root, intakeFile)}`);
+  console.log(`  ${path4.relative(root, attachmentsDir)}${path4.sep}`);
+  console.log(`
+Next: paste the tracker title, description, and acceptance criteria into the intake, then:`);
+  console.log(`  ${kleur2.bold(`squad new-plan ${path4.relative(root, intakeFile)}`)}`);
+  console.log(`  (or run ${kleur2.bold("/squad-plan")} in your agent)`);
+}
+function ensureFeatureOverview(featurePlanDir, slug) {
+  fs5.mkdirSync(featurePlanDir, { recursive: true });
+  const overviewFile = path4.join(featurePlanDir, "00-overview.md");
+  if (fs5.existsSync(overviewFile)) return;
+  const template = readFile(path4.join(templatesDir(), "overview.md"));
+  writeFileSafe(overviewFile, render(template, { featureSlug: slug }), false);
+}
+
+// src/commands/new-plan.ts
+import fs6 from "fs";
+import path5 from "path";
+import kleur3 from "kleur";
+
+// src/utils/clipboard.ts
+import { spawn } from "child_process";
+async function copyToClipboard(text) {
+  const cmd = clipboardCommand();
+  if (!cmd) return false;
+  return new Promise((resolve) => {
+    const child = spawn(cmd.command, cmd.args, { stdio: ["pipe", "ignore", "ignore"] });
+    child.on("error", () => resolve(false));
+    child.on("close", (code) => resolve(code === 0));
+    child.stdin.write(text);
+    child.stdin.end();
+  });
+}
+function clipboardCommand() {
+  if (process.platform === "darwin") return { command: "pbcopy", args: [] };
+  if (process.platform === "win32") return { command: "clip", args: [] };
+  if (process.env.WAYLAND_DISPLAY) return { command: "wl-copy", args: [] };
+  if (process.env.DISPLAY) return { command: "xclip", args: ["-selection", "clipboard"] };
+  return null;
+}
+
+// src/commands/new-plan.ts
+async function runNewPlan(intakePath, opts) {
+  if (!intakePath) {
+    throw new Error("intake-path is required. Usage: squad new-plan <path-to-intake.md>");
+  }
+  const root = requireSquadRoot();
+  const paths = buildPaths(root);
+  const config = loadConfig(paths.configFile);
+  const resolved = path5.resolve(intakePath);
+  if (!fs6.existsSync(resolved)) throw new Error(`Intake not found: ${resolved}`);
+  const intakeContent = readFile(resolved);
+  const metaPromptFile = path5.join(paths.promptsDir, "generate-plan.md");
+  if (!fs6.existsSync(metaPromptFile)) {
+    throw new Error(
+      `Missing meta-prompt at ${metaPromptFile}. Re-run \`squad init --force\` to restore templates.`
+    );
+  }
+  const metaPrompt = readFile(metaPromptFile);
+  const composed = render(metaPrompt, {
+    projectRoots: (config.project.projectRoots ?? ["."]).join(", "),
+    primaryLanguage: config.project.primaryLanguage ?? "",
+    trackerType: config.tracker.type,
+    intakeContent
+  });
+  process.stdout.write(composed);
+  if (!composed.endsWith("\n")) process.stdout.write("\n");
+  if (opts.copy !== false) {
+    const ok = await copyToClipboard(composed);
+    if (ok) console.error(kleur3.dim("\n(copied to clipboard)"));
+  }
+}
+
+// src/commands/status.ts
+import fs8 from "fs";
+import path7 from "path";
+import kleur4 from "kleur";
+
+// src/core/sequence.ts
+import fs7 from "fs";
+import path6 from "path";
+var STORY_FILE = /^(\d{2,})-story-.+\.md$/;
+function scanPlans(plansDir) {
+  const used = [];
+  const seen = /* @__PURE__ */ new Map();
+  if (fs7.existsSync(plansDir)) {
+    for (const feature of fs7.readdirSync(plansDir, { withFileTypes: true })) {
+      if (!feature.isDirectory()) continue;
+      const featureDir = path6.join(plansDir, feature.name);
+      for (const entry of fs7.readdirSync(featureDir)) {
+        const match = entry.match(STORY_FILE);
+        if (!match) continue;
+        const n = parseInt(match[1], 10);
+        used.push(n);
+        seen.set(n, (seen.get(n) ?? 0) + 1);
+      }
+    }
+  }
+  const duplicates = [...seen.entries()].filter(([, c]) => c > 1).map(([n]) => n);
+  const maxNumber = used.length ? Math.max(...used) : 0;
+  return { usedNumbers: used.sort((a, b) => a - b), maxNumber, duplicates, nextGlobal: maxNumber + 1 };
+}
+function formatSequence(n) {
+  return String(n).padStart(2, "0");
+}
+
+// src/commands/status.ts
+async function runStatus() {
+  const root = requireSquadRoot();
+  const paths = buildPaths(root);
+  const config = loadConfig(paths.configFile);
+  const scan = scanPlans(paths.plansDir);
+  const storyCount = countStories(paths.storiesDir);
+  const planCount = scan.usedNumbers.length;
+  console.log(kleur4.bold("squad-kit status"));
+  console.log(`  project:        ${config.project.name}`);
+  console.log(`  tracker:        ${config.tracker.type}`);
+  console.log(`  agents:         ${config.agents.length ? config.agents.join(", ") : "(none)"}`);
+  console.log(`  stories (drafts + planned): ${storyCount}`);
+  console.log(`  plan files:     ${planCount}`);
+  console.log(`  next NN:        ${formatSequence(scan.nextGlobal)}`);
+  if (scan.duplicates.length > 0) {
+    console.log(kleur4.yellow(`  \u26A0 duplicate NN numbers: ${scan.duplicates.map(formatSequence).join(", ")}`));
+  }
+}
+function countStories(storiesDir) {
+  if (!fs8.existsSync(storiesDir)) return 0;
+  let total = 0;
+  for (const feature of fs8.readdirSync(storiesDir, { withFileTypes: true })) {
+    if (!feature.isDirectory()) continue;
+    const featureDir = path7.join(storiesDir, feature.name);
+    for (const story of fs8.readdirSync(featureDir, { withFileTypes: true })) {
+      if (!story.isDirectory()) continue;
+      if (fs8.existsSync(path7.join(featureDir, story.name, "intake.md"))) total++;
+    }
+  }
+  return total;
+}
+
+// src/commands/list.ts
+import fs9 from "fs";
+import path8 from "path";
+import kleur5 from "kleur";
+async function runList(opts) {
+  const root = requireSquadRoot();
+  const paths = buildPaths(root);
+  const rows = [];
+  if (fs9.existsSync(paths.storiesDir)) {
+    for (const feature of fs9.readdirSync(paths.storiesDir, { withFileTypes: true })) {
+      if (!feature.isDirectory()) continue;
+      if (opts.feature && feature.name !== opts.feature) continue;
+      const featureDir = path8.join(paths.storiesDir, feature.name);
+      for (const story of fs9.readdirSync(featureDir, { withFileTypes: true })) {
+        if (!story.isDirectory()) continue;
+        const intake = path8.join(featureDir, story.name, "intake.md");
+        rows.push({
+          feature: feature.name,
+          id: story.name,
+          hasIntake: fs9.existsSync(intake),
+          planFile: findPlan(paths.plansDir, feature.name, story.name)
+        });
+      }
+    }
+  }
+  if (rows.length === 0) {
+    console.log(kleur5.dim("(no stories yet \u2014 try `squad new-story <feature-slug>`)"));
+    return;
+  }
+  const header = ["feature", "story", "intake", "plan"];
+  const table = rows.map((r) => [
+    r.feature,
+    r.id,
+    r.hasIntake ? "yes" : "\u2014",
+    r.planFile ?? kleur5.dim("\u2014")
+  ]);
+  printTable([header, ...table]);
+}
+function findPlan(plansDir, feature, storyId) {
+  const featureDir = path8.join(plansDir, feature);
+  if (!fs9.existsSync(featureDir)) return void 0;
+  for (const entry of fs9.readdirSync(featureDir)) {
+    if (entry.includes(storyId) && entry.endsWith(".md")) return entry;
+  }
+  return void 0;
+}
+function printTable(rows) {
+  const widths = rows[0].map((_, i) => Math.max(...rows.map((r) => stripAnsi(r[i] ?? "").length)));
+  for (const row of rows) {
+    console.log(row.map((cell, i) => pad(cell, widths[i])).join("  "));
+  }
+}
+function pad(s, width) {
+  const visible = stripAnsi(s).length;
+  return s + " ".repeat(Math.max(0, width - visible));
+}
+function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+// src/commands/tracker-link.ts
+import fs10 from "fs";
+import path9 from "path";
+import kleur6 from "kleur";
+async function runTrackerLink(storyPath, trackerId) {
+  if (!storyPath || !trackerId) {
+    throw new Error("Usage: squad tracker link <story-folder-or-intake> <tracker-id>");
+  }
+  const root = requireSquadRoot();
+  const paths = buildPaths(root);
+  const config = loadConfig(paths.configFile);
+  if (!validateTrackerId(config.tracker.type, trackerId)) {
+    throw new Error(`Invalid tracker id "${trackerId}" for tracker type "${config.tracker.type}".`);
+  }
+  const resolved = path9.resolve(storyPath);
+  const intakeFile = resolved.endsWith("intake.md") ? resolved : path9.join(resolved, "intake.md");
+  if (!fs10.existsSync(intakeFile)) throw new Error(`intake.md not found at ${intakeFile}`);
+  const content = fs10.readFileSync(intakeFile, "utf8");
+  const updated = upsertTrackerId(content, trackerId);
+  fs10.writeFileSync(intakeFile, updated, "utf8");
+  console.log(kleur6.green(`\u2713 Linked tracker id ${trackerId} \u2192 ${path9.relative(root, intakeFile)}`));
+}
+function upsertTrackerId(content, id) {
+  const pattern = /(-\s*\*\*Work item id:\*\*)[^\n]*/;
+  if (pattern.test(content)) {
+    return content.replace(pattern, `$1 ${id}`);
+  }
+  return content + `
+
+- **Work item id:** ${id}
+`;
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("squad").description("Plan once, execute cheap. A 3-step SDD workflow CLI.").version("0.1.0");
+program.command("init").description("Bootstrap .squad/ in the current directory").option("--agents <list>", "Comma-separated agent list: claude-code,cursor,copilot,gemini").option("--tracker <type>", "Tracker type: none|github|linear|jira|azure").option("--name <name>", "Project name").option("--language <lang>", "Primary language").option("--force", "Overwrite existing files", false).option("-y, --yes", "Accept defaults (non-interactive)", false).action(wrap(runInit));
+program.command("new-story <feature-slug>").description("Scaffold a new story intake under .squad/stories/<feature>/<id>/").option("--id <id>", "Tracker work-item id (required when tracker is not none and naming.includeTrackerId is true)").option("--title <title>", "Short title hint (placed at top of intake)").option("-y, --yes", "Fail fast instead of prompting for missing values", false).action(wrapArgs(runNewStory));
+program.command("new-plan <intake-path>").description("Compose the plan-generation meta-prompt with intake content; prints to stdout and copies to clipboard").option("--no-copy", "Do not copy the composed prompt to clipboard").action(wrapArgs(runNewPlan));
+program.command("status").description("Show squad-kit workspace status").action(wrap(runStatus));
+program.command("list").description("List stories and their plan state").option("--feature <slug>", "Filter by feature slug").action(wrap(runList));
+var tracker = program.command("tracker").description("Tracker id helpers");
+tracker.command("link <story-path> <tracker-id>").description("Attach/update a tracker id on an existing story intake").action(wrapArgs(runTrackerLink));
+program.parseAsync(process.argv).catch((err) => {
+  console.error(kleur7.red(`error: ${err.message}`));
+  process.exit(1);
+});
+function wrap(fn) {
+  return async (opts) => {
+    try {
+      await fn(opts);
+    } catch (err) {
+      console.error(kleur7.red(`error: ${err.message}`));
+      process.exit(1);
+    }
+  };
+}
+function wrapArgs(fn) {
+  return async (...args) => {
+    try {
+      await fn(...args);
+    } catch (err) {
+      console.error(kleur7.red(`error: ${err.message}`));
+      process.exit(1);
+    }
+  };
+}
+//# sourceMappingURL=cli.js.map