@abranjith/spec-lite 0.0.1

package/dist/index.js

@@ -0,0 +1,903 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import path6 from "path";
+import fs6 from "fs-extra";
+import chalk from "chalk";
+import inquirer from "inquirer";
+
+// src/providers/copilot.ts
+import path from "path";
+import fs from "fs-extra";
+var CopilotProvider = class {
+  name = "GitHub Copilot";
+  alias = "copilot";
+  description = "GitHub Copilot (VS Code, JetBrains, Neovim)";
+  getTargetPath(promptName) {
+    return path.join(".github", "copilot", `${promptName}.prompt.md`);
+  }
+  transformPrompt(content, meta) {
+    const header = [
+      `<!-- spec-lite | ${meta.name} | DO NOT EDIT below the project-context block \u2014 managed by spec-lite -->`,
+      `<!-- To update: run "spec-lite update" \u2014 your Project Context edits will be preserved -->`,
+      ""
+    ].join("\n");
+    return header + content;
+  }
+  async detectExisting(workspaceRoot) {
+    const existing = [];
+    const copilotDir = path.join(workspaceRoot, ".github", "copilot");
+    if (await fs.pathExists(copilotDir)) {
+      const files = await fs.readdir(copilotDir);
+      for (const f of files) {
+        if (f.endsWith(".prompt.md") || f.endsWith(".md")) {
+          existing.push(path.join(".github", "copilot", f));
+        }
+      }
+    }
+    const mainFile = path.join(
+      workspaceRoot,
+      ".github",
+      "copilot-instructions.md"
+    );
+    if (await fs.pathExists(mainFile)) {
+      existing.push(".github/copilot-instructions.md");
+    }
+    return existing;
+  }
+  getPostInitMessage() {
+    return [
+      "",
+      "\u{1F4CB} GitHub Copilot setup complete!",
+      "",
+      "  Your sub-agent prompts are in .github/copilot/",
+      "",
+      "  How to use:",
+      "  1. Open GitHub Copilot Chat in VS Code",
+      "  2. Sub-agents are available as slash commands \u2014 type /prompt_name",
+      "     (e.g., /brainstorm, /planner, /feature)",
+      "  3. Files ending in .prompt.md are natively recognized by Copilot",
+      "  4. Customize the Project Context block in each file for your project",
+      ""
+    ].join("\n");
+  }
+};
+
+// src/providers/claude-code.ts
+import path2 from "path";
+import fs2 from "fs-extra";
+var ClaudeCodeProvider = class {
+  name = "Claude Code";
+  alias = "claude-code";
+  description = "Claude Code (Anthropic's coding agent)";
+  getTargetPath(promptName) {
+    return path2.join(".claude", "prompts", `${promptName}.md`);
+  }
+  transformPrompt(content, meta) {
+    const header = [
+      `<!-- spec-lite | ${meta.name} | DO NOT EDIT below the project-context block \u2014 managed by spec-lite -->`,
+      `<!-- To update: run "spec-lite update" \u2014 your Project Context edits will be preserved -->`,
+      ""
+    ].join("\n");
+    return header + content;
+  }
+  async detectExisting(workspaceRoot) {
+    const existing = [];
+    const claudePromptsDir = path2.join(
+      workspaceRoot,
+      ".claude",
+      "prompts"
+    );
+    if (await fs2.pathExists(claudePromptsDir)) {
+      const files = await fs2.readdir(claudePromptsDir);
+      for (const f of files) {
+        if (f.endsWith(".md")) {
+          existing.push(path2.join(".claude", "prompts", f));
+        }
+      }
+    }
+    const rootFile = path2.join(workspaceRoot, "CLAUDE.md");
+    if (await fs2.pathExists(rootFile)) {
+      existing.push("CLAUDE.md");
+    }
+    return existing;
+  }
+  getPostInitMessage() {
+    return [
+      "",
+      "\u{1F4CB} Claude Code setup complete!",
+      "",
+      "  Your sub-agent prompts are in .claude/prompts/",
+      "  A root CLAUDE.md has been created with references to the sub-agents.",
+      "",
+      "  How to use:",
+      "  1. Claude Code automatically reads CLAUDE.md for project context",
+      '  2. Reference specific sub-agents: "Use the planner from .claude/prompts/planner.md"',
+      "  3. Customize the Project Context block in each file for your project",
+      ""
+    ].join("\n");
+  }
+};
+function generateClaudeRootMd(installedPrompts) {
+  const lines = [
+    "<!-- spec-lite managed \u2014 regenerated on spec-lite init/update -->",
+    "",
+    "# Project Instructions",
+    "",
+    "This project uses [spec-lite](https://github.com/ranjithab/spec-lite) sub-agent prompts",
+    "for structured software engineering workflows.",
+    "",
+    "## Available Sub-Agents",
+    "",
+    "The following specialist sub-agents are available in `.claude/prompts/`:",
+    ""
+  ];
+  for (const name of installedPrompts) {
+    lines.push(`- [${name}](.claude/prompts/${name}.md)`);
+  }
+  lines.push(
+    "",
+    "## Usage",
+    "",
+    "To use a sub-agent, reference its prompt file in your conversation:",
+    "",
+    "```text",
+    "Use the planner from .claude/prompts/planner.md to create a technical plan for this project.",
+    "```",
+    "",
+    "## Output Directory",
+    "",
+    "Sub-agent outputs are written to the `.spec/` directory:",
+    "",
+    "```text",
+    ".spec/",
+    "\u251C\u2500\u2500 brainstorm.md",
+    "\u251C\u2500\u2500 plan.md                    # Default plan (simple projects)",
+    "\u251C\u2500\u2500 plan_<name>.md              # Named plans (complex projects)",
+    "\u251C\u2500\u2500 TODO.md",
+    "\u251C\u2500\u2500 features/",
+    "\u2514\u2500\u2500 reviews/",
+    "```",
+    ""
+  );
+  return lines.join("\n");
+}
+
+// src/providers/generic.ts
+import path3 from "path";
+import fs3 from "fs-extra";
+var GenericProvider = class {
+  name = "Generic";
+  alias = "generic";
+  description = "Raw prompts in .spec-lite/prompts/ (copy-paste into any LLM)";
+  getTargetPath(promptName) {
+    return path3.join(".spec-lite", "prompts", `${promptName}.md`);
+  }
+  transformPrompt(content, meta) {
+    const header = [
+      `<!-- spec-lite | ${meta.name} | managed by spec-lite -->`,
+      `<!-- To update: run "spec-lite update" -->`,
+      ""
+    ].join("\n");
+    return header + content;
+  }
+  async detectExisting(workspaceRoot) {
+    const existing = [];
+    const dir = path3.join(workspaceRoot, ".spec-lite", "prompts");
+    if (await fs3.pathExists(dir)) {
+      const files = await fs3.readdir(dir);
+      for (const f of files) {
+        if (f.endsWith(".md")) {
+          existing.push(path3.join(".spec-lite", "prompts", f));
+        }
+      }
+    }
+    return existing;
+  }
+  getPostInitMessage() {
+    return [
+      "",
+      "\u{1F4CB} Generic setup complete!",
+      "",
+      "  Your sub-agent prompts are in .spec-lite/prompts/",
+      "",
+      "  How to use:",
+      "  1. Open any prompt file and copy its content",
+      "  2. Paste into your LLM of choice (ChatGPT, Claude, Gemini, etc.)",
+      "  3. Fill in the Project Context section for your project",
+      "  4. Start the conversation with your requirements",
+      ""
+    ].join("\n");
+  }
+};
+
+// src/providers/index.ts
+var providers = [
+  new CopilotProvider(),
+  new ClaudeCodeProvider(),
+  new GenericProvider()
+];
+function getProvider(alias) {
+  return providers.find((p) => p.alias === alias);
+}
+function getAllProviders() {
+  return [...providers];
+}
+
+// src/utils/prompts.ts
+import path4 from "path";
+import fs4 from "fs-extra";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path4.dirname(__filename);
+function getPromptsDir() {
+  return path4.resolve(__dirname, "..", "prompts");
+}
+var PROMPT_CATALOG = {
+  spec_help: {
+    title: "Spec Help",
+    description: "Lists available sub-agents, their purpose, inputs, and outputs",
+    output: "(interactive guide)"
+  },
+  brainstorm: {
+    title: "Brainstorm",
+    description: "Refines a vague idea into a clear, actionable vision",
+    output: ".spec/brainstorm.md"
+  },
+  planner: {
+    title: "Planner",
+    description: "Creates a detailed technical blueprint from requirements",
+    output: ".spec/plan.md or .spec/plan_<name>.md"
+  },
+  feature: {
+    title: "Feature",
+    description: "Breaks one feature into granular, verifiable vertical slices",
+    output: ".spec/features/feature_<name>.md"
+  },
+  implement: {
+    title: "Implement",
+    description: "Picks up a feature spec and executes its tasks with code",
+    output: "Working code + updated feature spec"
+  },
+  code_review: {
+    title: "Code Review",
+    description: "Reviews code for correctness, architecture, and readability",
+    output: ".spec/reviews/code_review_<name>.md"
+  },
+  security_audit: {
+    title: "Security Audit",
+    description: "Scans for vulnerabilities, misconfigurations, and security risks",
+    output: ".spec/reviews/security_audit_<scope>.md"
+  },
+  performance_review: {
+    title: "Performance Review",
+    description: "Identifies bottlenecks and optimization opportunities",
+    output: ".spec/reviews/performance_review_<scope>.md"
+  },
+  integration_tests: {
+    title: "Integration Tests",
+    description: "Writes traceable integration test scenarios from feature specs",
+    output: "tests/"
+  },
+  unit_tests: {
+    title: "Unit Tests",
+    description: "Generates comprehensive unit tests with edge-case coverage and smart coverage exclusions",
+    output: ".spec/features/unit_tests_<name>.md"
+  },
+  devops: {
+    title: "DevOps",
+    description: "Sets up Docker, CI/CD, environments, and deployment",
+    output: "Project infrastructure files"
+  },
+  fix: {
+    title: "Fix & Refactor",
+    description: "Debugs issues or restructures code safely",
+    output: "Targeted fixes with verification"
+  },
+  memorize: {
+    title: "Memorize",
+    description: "Stores standing instructions that all sub-agents enforce. Use `/memorize bootstrap` to auto-generate from project analysis.",
+    output: ".spec/memory.md"
+  },
+  technical_docs: {
+    title: "Technical Docs",
+    description: "Creates deep architecture documentation for developers",
+    output: "docs/technical_architecture.md"
+  },
+  readme: {
+    title: "README",
+    description: "Writes the project README and optional user guide",
+    output: "README.md + docs/user_guide.md"
+  }
+};
+var SKIP_FILES = /* @__PURE__ */ new Set(["orchestrator"]);
+async function loadPrompts(exclude = []) {
+  const promptsDir = getPromptsDir();
+  const excludeSet = /* @__PURE__ */ new Set([...exclude, ...SKIP_FILES]);
+  const files = await fs4.readdir(promptsDir);
+  const prompts = [];
+  for (const file of files) {
+    if (!file.endsWith(".md")) continue;
+    const name = file.replace(".md", "");
+    if (excludeSet.has(name)) continue;
+    const filePath = path4.join(promptsDir, file);
+    const content = await fs4.readFile(filePath, "utf-8");
+    const catalog = PROMPT_CATALOG[name];
+    prompts.push({
+      name,
+      filePath,
+      content,
+      title: catalog?.title ?? name,
+      description: catalog?.description ?? ""
+    });
+  }
+  return prompts;
+}
+function getPromptCatalog() {
+  return PROMPT_CATALOG;
+}
+var CONTEXT_START_MARKER = "<!-- project-context-start -->";
+var CONTEXT_END_MARKER = "<!-- project-context-end -->";
+function extractProjectContext(content) {
+  const startIdx = content.indexOf(CONTEXT_START_MARKER);
+  const endIdx = content.indexOf(CONTEXT_END_MARKER);
+  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) return null;
+  return content.substring(
+    startIdx + CONTEXT_START_MARKER.length,
+    endIdx
+  );
+}
+function replaceProjectContext(content, newContext) {
+  const startIdx = content.indexOf(CONTEXT_START_MARKER);
+  const endIdx = content.indexOf(CONTEXT_END_MARKER);
+  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) return content;
+  return content.substring(0, startIdx + CONTEXT_START_MARKER.length) + newContext + content.substring(endIdx);
+}
+
+// src/utils/stacks.ts
+import path5 from "path";
+import fs5 from "fs-extra";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path5.dirname(__filename2);
+function getStacksDir() {
+  return path5.resolve(__dirname2, "stacks");
+}
+var LANGUAGE_MAP = {
+  typescript: "typescript.md",
+  ts: "typescript.md",
+  javascript: "typescript.md",
+  js: "typescript.md",
+  "node.js": "typescript.md",
+  node: "typescript.md",
+  react: "react.md",
+  "react.js": "react.md",
+  "next.js": "react.md",
+  nextjs: "react.md",
+  python: "python.md",
+  py: "python.md",
+  "c#": "dotnet.md",
+  csharp: "dotnet.md",
+  ".net": "dotnet.md",
+  dotnet: "dotnet.md",
+  java: "java.md",
+  "spring": "java.md",
+  "spring boot": "java.md",
+  "spring-boot": "java.md"
+};
+function getStackSnippet(language) {
+  const key = language.toLowerCase().trim();
+  const filename = LANGUAGE_MAP[key];
+  if (!filename) return null;
+  const filePath = path5.join(getStacksDir(), filename);
+  if (!fs5.pathExistsSync(filePath)) return null;
+  return fs5.readFileSync(filePath, "utf-8");
+}
+
+// src/commands/init.ts
+var LANGUAGE_CHOICES = [
+  { name: "TypeScript", value: "TypeScript" },
+  { name: "Python", value: "Python" },
+  { name: "Java", value: "Java" },
+  { name: "C# / .NET", value: "C#" },
+  { name: "Go", value: "Go" },
+  { name: "Rust", value: "Rust" },
+  { name: "Other (specify below)", value: "__other__" }
+];
+var ARCHITECTURE_CHOICES = [
+  { name: "Monolith", value: "Monolith" },
+  { name: "Microservices", value: "Microservices" },
+  { name: "Serverless", value: "Serverless" },
+  { name: "Monorepo", value: "Monorepo" },
+  { name: "Other (specify below)", value: "__other__" }
+];
+async function collectProjectProfile() {
+  console.log(
+    chalk.cyan(
+      "\n  \u{1F4CB} Project Profile \u2014 a few questions to personalize your setup:\n"
+    )
+  );
+  const answers = await inquirer.prompt([
+    {
+      type: "list",
+      name: "language",
+      message: "Primary programming language?",
+      choices: LANGUAGE_CHOICES
+    },
+    {
+      type: "input",
+      name: "languageOther",
+      message: "Specify your primary language:",
+      when: (prev) => prev.language === "__other__",
+      validate: (input) => input.trim() ? true : "Please enter a language."
+    },
+    {
+      type: "input",
+      name: "frameworks",
+      message: 'Framework(s) in use? (e.g., "Express + React", "FastAPI", "ASP.NET Core")',
+      default: "None / not sure yet"
+    },
+    {
+      type: "input",
+      name: "testFramework",
+      message: 'Testing framework? (e.g., "Jest", "Vitest", "pytest", "xUnit")',
+      default: "Not decided yet"
+    },
+    {
+      type: "list",
+      name: "architecture",
+      message: "Architectural pattern?",
+      choices: ARCHITECTURE_CHOICES
+    },
+    {
+      type: "input",
+      name: "architectureOther",
+      message: "Specify your architectural pattern:",
+      when: (prev) => prev.architecture === "__other__",
+      validate: (input) => input.trim() ? true : "Please enter a pattern."
+    },
+    {
+      type: "input",
+      name: "conventions",
+      message: 'Any specific coding conventions? (e.g., "Airbnb style guide", "PEP 8") \u2014 leave blank if none',
+      default: ""
+    }
+  ]);
+  return {
+    language: answers.language === "__other__" ? answers.languageOther.trim() : answers.language,
+    frameworks: answers.frameworks.trim(),
+    testFramework: answers.testFramework.trim(),
+    architecture: answers.architecture === "__other__" ? answers.architectureOther.trim() : answers.architecture,
+    conventions: answers.conventions.trim()
+  };
+}
+function buildProjectContextBlock(profile) {
+  const lines = [
+    "",
+    "## Project Context (Customize per project)",
+    "",
+    "> Auto-populated by spec-lite init. Edit these values as your project evolves.",
+    "",
+    `- **Language(s)**: ${profile.language}`,
+    `- **Framework(s)**: ${profile.frameworks}`,
+    `- **Test Framework**: ${profile.testFramework}`,
+    `- **Architecture**: ${profile.architecture}`
+  ];
+  if (profile.conventions) {
+    lines.push(`- **Conventions**: ${profile.conventions}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+async function initCommand(options) {
+  const cwd = process.cwd();
+  console.log(chalk.bold("\n\u26A1 spec-lite init\n"));
+  let providerAlias = options.ai;
+  if (!providerAlias) {
+    const providers2 = getAllProviders();
+    const answer = await inquirer.prompt([
+      {
+        type: "list",
+        name: "provider",
+        message: "Which AI coding assistant are you using?",
+        choices: providers2.map((p) => ({
+          name: `${p.name} \u2014 ${p.description}`,
+          value: p.alias
+        }))
+      }
+    ]);
+    providerAlias = answer.provider;
+  }
+  const provider = getProvider(providerAlias);
+  if (!provider) {
+    console.error(
+      chalk.red(
+        `Unknown provider: "${providerAlias}". Available: ${getAllProviders().map((p) => p.alias).join(", ")}`
+      )
+    );
+    process.exit(1);
+  }
+  console.log(chalk.cyan(`  Provider: ${provider.name}`));
+  let projectProfile;
+  if (!options.skipProfile) {
+    projectProfile = await collectProjectProfile();
+    console.log(chalk.green("  \u2713 Project profile collected"));
+  } else {
+    console.log(chalk.dim("  Skipping project profile questionnaire."));
+  }
+  const exclude = options.exclude ? options.exclude.split(/[,\s]+/).map((s) => s.trim()).filter(Boolean) : [];
+  if (exclude.length > 0) {
+    console.log(chalk.dim(`  Excluding: ${exclude.join(", ")}`));
+  }
+  const existingFiles = await provider.detectExisting(cwd);
+  if (existingFiles.length > 0 && !options.force) {
+    console.log(
+      chalk.yellow(
+        `
+  Found existing instruction files:
+${existingFiles.map((f) => `    - ${f}`).join("\n")}`
+      )
+    );
+    const answer = await inquirer.prompt([
+      {
+        type: "list",
+        name: "action",
+        message: "How should we handle existing files?",
+        choices: [
+          {
+            name: "Overwrite \u2014 replace all existing files",
+            value: "overwrite"
+          },
+          {
+            name: "Skip \u2014 only write files that don't exist yet",
+            value: "skip"
+          },
+          { name: "Abort \u2014 cancel initialization", value: "abort" }
+        ]
+      }
+    ]);
+    if (answer.action === "abort") {
+      console.log(chalk.dim("  Aborted."));
+      return;
+    }
+    if (answer.action === "skip") {
+      console.log(chalk.dim("  Skipping existing files."));
+    }
+  }
+  const contextBlock = projectProfile ? buildProjectContextBlock(projectProfile) : null;
+  const prompts = await loadPrompts(exclude);
+  let written = 0;
+  let skipped = 0;
+  const installedPrompts = [];
+  for (const prompt of prompts) {
+    const targetRelPath = provider.getTargetPath(prompt.name);
+    const targetAbsPath = path6.join(cwd, targetRelPath);
+    if (!options.force && existingFiles.includes(targetRelPath) && existingFiles.length > 0) {
+      const answer = await inquirer.prompt([
+        {
+          type: "list",
+          name: "action",
+          message: `How should we handle existing files?`,
+          choices: [
+            { name: "Overwrite", value: "overwrite" },
+            { name: "Skip", value: "skip" }
+          ]
+        }
+      ]);
+      if (answer.action === "skip") {
+        skipped++;
+        installedPrompts.push(prompt.name);
+        continue;
+      }
+    }
+    let content = prompt.content;
+    if (contextBlock) {
+      content = replaceProjectContext(content, contextBlock);
+    }
+    const transformed = provider.transformPrompt(content, {
+      name: prompt.name,
+      title: prompt.title,
+      description: prompt.description
+    });
+    await fs6.ensureDir(path6.dirname(targetAbsPath));
+    await fs6.writeFile(targetAbsPath, transformed, "utf-8");
+    written++;
+    installedPrompts.push(prompt.name);
+    console.log(chalk.green(`  \u2713 ${targetRelPath}`));
+  }
+  if (provider.alias === "claude-code") {
+    const claudeMdPath = path6.join(cwd, "CLAUDE.md");
+    const claudeMdContent = generateClaudeRootMd(installedPrompts);
+    await fs6.writeFile(claudeMdPath, claudeMdContent, "utf-8");
+    console.log(chalk.green(`  \u2713 CLAUDE.md`));
+    written++;
+  }
+  const specDirs = [
+    ".spec",
+    path6.join(".spec", "features"),
+    path6.join(".spec", "reviews")
+  ];
+  for (const dir of specDirs) {
+    const absDir = path6.join(cwd, dir);
+    if (!await fs6.pathExists(absDir)) {
+      await fs6.ensureDir(absDir);
+      console.log(chalk.green(`  \u2713 ${dir}/`));
+    }
+  }
+  const todoPath = path6.join(cwd, ".spec", "TODO.md");
+  if (!await fs6.pathExists(todoPath)) {
+    const todoContent = [
+      "# TODO \u2014 Enhancements & Ideas",
+      "",
+      "> Discovered by sub-agents during planning and development.",
+      "> Items here are out-of-scope for their current task but worth tracking.",
+      "",
+      "## General",
+      "",
+      "## General / Caching",
+      "",
+      "## UI",
+      "",
+      "## Performance",
+      "",
+      "## Security",
+      "",
+      "## DX (Developer Experience)",
+      ""
+    ].join("\n");
+    await fs6.writeFile(todoPath, todoContent, "utf-8");
+    console.log(chalk.green(`  \u2713 .spec/TODO.md`));
+  }
+  if (projectProfile) {
+    const snippet = getStackSnippet(projectProfile.language);
+    if (snippet) {
+      const stacksTargetDir = path6.join(cwd, ".spec-lite", "stacks");
+      await fs6.ensureDir(stacksTargetDir);
+      const snippetFileName = `${projectProfile.language.toLowerCase().replace(/[^a-z0-9]/g, "-")}.md`;
+      const snippetPath = path6.join(stacksTargetDir, snippetFileName);
+      if (await fs6.pathExists(snippetPath) && !options.force) {
+        console.log(
+          chalk.dim(`  \u2013 .spec-lite/stacks/${snippetFileName} already exists (kept your edits)`)
+        );
+      } else {
+        await fs6.writeFile(snippetPath, snippet, "utf-8");
+        console.log(
+          chalk.green(`  \u2713 .spec-lite/stacks/${snippetFileName}`)
+        );
+        console.log(
+          chalk.dim("     \u21B3 Edit this file to customize defaults before running /memorize bootstrap")
+        );
+        written++;
+      }
+    }
+  }
+  const pkg2 = await loadPackageVersion();
+  const config = {
+    version: pkg2,
+    provider: provider.alias,
+    installedPrompts,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...projectProfile ? { projectProfile } : {}
+  };
+  const configPath = path6.join(cwd, ".spec-lite.json");
+  await fs6.writeJson(configPath, config, { spaces: 2 });
+  console.log(chalk.green(`  \u2713 .spec-lite.json`));
+  console.log(
+    chalk.bold(
+      `
+  Done! ${written} files written, ${skipped} skipped.`
+    )
+  );
+  console.log(provider.getPostInitMessage());
+  if (projectProfile) {
+    console.log(
+      chalk.cyan(
+        "\n  \u{1F4CC} Next step: Run "
+      ) + chalk.bold("/memorize bootstrap") + chalk.cyan(
+        " in your AI assistant to auto-generate\n     coding standards, architecture guidelines, and best practices\n     for your project based on the profile you just provided."
+      )
+    );
+  }
+}
+async function loadPackageVersion() {
+  try {
+    const { createRequire: createRequire2 } = await import("module");
+    const require3 = createRequire2(import.meta.url);
+    const pkg2 = require3("../../package.json");
+    return pkg2.version;
+  } catch {
+    return "1.0.0";
+  }
+}
+
+// src/commands/update.ts
+import path7 from "path";
+import fs7 from "fs-extra";
+import chalk2 from "chalk";
+async function updateCommand(options) {
+  const cwd = process.cwd();
+  console.log(chalk2.bold("\n\u26A1 spec-lite update\n"));
+  const configPath = path7.join(cwd, ".spec-lite.json");
+  if (!await fs7.pathExists(configPath)) {
+    console.error(
+      chalk2.red(
+        '  No .spec-lite.json found. Run "spec-lite init" first.'
+      )
+    );
+    process.exit(1);
+  }
+  const config = await fs7.readJson(configPath);
+  const provider = getProvider(config.provider);
+  if (!provider) {
+    console.error(
+      chalk2.red(
+        `  Unknown provider "${config.provider}" in .spec-lite.json. Re-run "spec-lite init".`
+      )
+    );
+    process.exit(1);
+  }
+  console.log(chalk2.cyan(`  Provider: ${provider.name}`));
+  console.log(
+    chalk2.dim(`  Installed: ${config.installedPrompts.length} prompts`)
+  );
+  const allPrompts = await loadPrompts();
+  const installedSet = new Set(config.installedPrompts);
+  const prompts = allPrompts.filter((p) => installedSet.has(p.name));
+  let updated = 0;
+  let preserved = 0;
+  let unchanged = 0;
+  let migrated = 0;
+  for (const prompt of prompts) {
+    const targetRelPath = provider.getTargetPath(prompt.name);
+    const targetAbsPath = path7.join(cwd, targetRelPath);
+    if (provider.alias === "copilot") {
+      const oldRelPath = path7.join(".github", "copilot", `${prompt.name}.md`);
+      const oldAbsPath = path7.join(cwd, oldRelPath);
+      if (targetRelPath !== oldRelPath && await fs7.pathExists(oldAbsPath) && !await fs7.pathExists(targetAbsPath)) {
+        await fs7.ensureDir(path7.dirname(targetAbsPath));
+        await fs7.rename(oldAbsPath, targetAbsPath);
+        console.log(
+          chalk2.cyan(
+            `  \u2197 ${oldRelPath} \u2192 ${targetRelPath} (migrated to .prompt.md)`
+          )
+        );
+        migrated++;
+      }
+    }
+    const newContent = provider.transformPrompt(prompt.content, {
+      name: prompt.name,
+      title: prompt.title,
+      description: prompt.description
+    });
+    if (!await fs7.pathExists(targetAbsPath)) {
+      await fs7.ensureDir(path7.dirname(targetAbsPath));
+      await fs7.writeFile(targetAbsPath, newContent, "utf-8");
+      console.log(chalk2.green(`  \u2713 ${targetRelPath} (restored)`));
+      updated++;
+      continue;
+    }
+    const currentContent = await fs7.readFile(targetAbsPath, "utf-8");
+    if (currentContent === newContent) {
+      unchanged++;
+      continue;
+    }
+    if (!options.force) {
+      const userContext = extractProjectContext(currentContent);
+      if (userContext) {
+        const mergedContent = replaceProjectContext(newContent, userContext);
+        await fs7.writeFile(targetAbsPath, mergedContent, "utf-8");
+        console.log(
+          chalk2.green(
+            `  \u2713 ${targetRelPath} (updated, Project Context preserved)`
+          )
+        );
+        preserved++;
+        updated++;
+        continue;
+      }
+    }
+    await fs7.writeFile(targetAbsPath, newContent, "utf-8");
+    console.log(chalk2.green(`  \u2713 ${targetRelPath} (updated)`));
+    updated++;
+  }
+  if (provider.alias === "claude-code") {
+    const claudeMdPath = path7.join(cwd, "CLAUDE.md");
+    const claudeMdContent = generateClaudeRootMd(config.installedPrompts);
+    await fs7.writeFile(claudeMdPath, claudeMdContent, "utf-8");
+    console.log(chalk2.green(`  \u2713 CLAUDE.md (regenerated)`));
+  }
+  config.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const { createRequire: createRequire2 } = await import("module");
+    const require3 = createRequire2(import.meta.url);
+    const pkg2 = require3("../../package.json");
+    config.version = pkg2.version;
+  } catch {
+  }
+  await fs7.writeJson(configPath, config, { spaces: 2 });
+  console.log(
+    chalk2.bold(
+      `
+  Done! ${updated} updated, ${unchanged} unchanged, ${preserved} with preserved edits${migrated > 0 ? `, ${migrated} migrated` : ""}.`
+    )
+  );
+}
+
+// src/commands/list.ts
+import chalk3 from "chalk";
+async function listCommand() {
+  const catalog = getPromptCatalog();
+  console.log(chalk3.bold("\n\u26A1 spec-lite \u2014 Available Sub-Agents\n"));
+  console.log(
+    chalk3.dim(
+      "  Each sub-agent is a specialist prompt for one phase of the development lifecycle.\n"
+    )
+  );
+  const entries = Object.entries(catalog);
+  const maxName = Math.max(...entries.map(([name]) => name.length), 4);
+  const maxTitle = Math.max(
+    ...entries.map(([, v]) => v.title.length),
+    5
+  );
+  const header = `  ${"Name".padEnd(maxName + 2)}${"Title".padEnd(maxTitle + 2)}${"Description"}`;
+  console.log(chalk3.cyan(header));
+  console.log(chalk3.dim(`  ${"\u2500".repeat(header.trim().length + 10)}`));
+  for (const [name, meta] of entries) {
+    const nameCol = chalk3.green(name.padEnd(maxName + 2));
+    const titleCol = chalk3.white(meta.title.padEnd(maxTitle + 2));
+    const descCol = chalk3.dim(meta.description);
+    console.log(`  ${nameCol}${titleCol}${descCol}`);
+    if (meta.output) {
+      console.log(
+        `  ${"".padEnd(maxName + 2)}${"".padEnd(maxTitle + 2)}${chalk3.dim(`\u2192 ${meta.output}`)}`
+      );
+    }
+  }
+  console.log(
+    chalk3.dim(
+      `
+  ${entries.length} sub-agents available. Run "spec-lite init" to install them.
+`
+    )
+  );
+  console.log(chalk3.bold("  Recommended Pipeline:\n"));
+  console.log(
+    chalk3.dim(
+      "  Brainstorm \u2192 Planner \u2192 Feature (\xD7N) \u2192 Reviews \u2192 Tests \u2192 DevOps \u2192 Docs"
+    )
+  );
+  console.log(
+    chalk3.dim(
+      "  (Not every project needs every sub-agent. Start with Planner if you have clear requirements.)\n"
+    )
+  );
+}
+
+// src/index.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var program = new Command();
+program.name("spec-lite").description(
+  "Install structured AI sub-agent prompts into your workspace for any AI coding assistant"
+).version(pkg.version);
+program.command("init").description("Initialize spec-lite sub-agent prompts in your workspace").option(
+  "--ai <provider>",
+  "AI provider to configure for (copilot, claude-code, generic)"
+).option(
+  "--exclude <prompts>",
+  "Comma-separated list of prompts to exclude (e.g., brainstorm,readme)"
+).option("--force", "Overwrite existing files without prompting", false).option(
+  "--skip-profile",
+  "Skip the project profile questionnaire (for CI/scripting)"
+).action(initCommand);
+program.command("update").description(
+  "Update spec-lite prompts to the latest version, preserving your Project Context edits"
+).option("--force", "Overwrite all files including user-modified ones", false).action(updateCommand);
+program.command("list").description("List all available spec-lite sub-agents and their purpose").action(listCommand);
+program.parse();
+//# sourceMappingURL=index.js.map