spets 0.1.0

package/dist/index.js

@@ -0,0 +1,1424 @@
+#!/usr/bin/env node
+import {
+  generateTaskId,
+  getOutputPath,
+  getSeptDir,
+  getWorkflowState,
+  listTasks,
+  loadConfig,
+  loadDocument,
+  loadStepDefinition,
+  loadTaskMetadata,
+  saveDocument,
+  saveTaskMetadata,
+  septExists,
+  updateDocumentStatus
+} from "./chunk-KZQ5KNMC.js";
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+async function initCommand(options) {
+  const cwd = process.cwd();
+  const septDir = getSeptDir(cwd);
+  if (septExists(cwd) && !options.force) {
+    console.error("Spets already initialized. Use --force to overwrite.");
+    process.exit(1);
+  }
+  mkdirSync(septDir, { recursive: true });
+  mkdirSync(join(septDir, "steps"), { recursive: true });
+  mkdirSync(join(septDir, "outputs"), { recursive: true });
+  mkdirSync(join(septDir, "hooks"), { recursive: true });
+  const templatesDir = join(__dirname, "..", "templates");
+  writeFileSync(join(septDir, "config.yml"), getDefaultConfig());
+  createDefaultSteps(septDir);
+  console.log("Initialized spets in .sept/");
+  console.log("");
+  console.log("Created:");
+  console.log("  .sept/config.yml         - Workflow configuration");
+  console.log("  .sept/steps/01-plan/     - Planning step");
+  console.log("  .sept/steps/02-implement/ - Implementation step");
+  if (options.github) {
+    createGitHubWorkflow(cwd);
+    console.log("  .github/workflows/sept.yml - GitHub Actions workflow");
+  }
+  console.log("");
+  console.log("Next steps:");
+  console.log("  1. Edit .sept/config.yml to customize your workflow");
+  console.log("  2. Customize step instructions in .sept/steps/");
+  if (options.github) {
+    console.log("  3. Add ANTHROPIC_API_KEY to your repo secrets");
+    console.log('  4. Run: spets start "task" --platform github --owner <owner> --repo <repo> --issue <n>');
+  } else {
+    console.log('  3. Run: spets start "your task description"');
+  }
+}
+function getDefaultConfig() {
+  return `# Spets Configuration
+# Define your workflow steps here
+
+steps:
+  - 01-plan
+  - 02-implement
+
+# Optional hooks (shell scripts)
+# hooks:
+#   preStep: "./hooks/pre-step.sh"
+#   postStep: "./hooks/post-step.sh"
+#   onApprove: "./hooks/on-approve.sh"
+#   onReject: "./hooks/on-reject.sh"
+#   onComplete: "./hooks/on-complete.sh"
+`;
+}
+function createDefaultSteps(septDir) {
+  const planDir = join(septDir, "steps", "01-plan");
+  mkdirSync(planDir, { recursive: true });
+  writeFileSync(join(planDir, "instruction.md"), getPlanInstruction());
+  writeFileSync(join(planDir, "template.md"), getPlanTemplate());
+  const implementDir = join(septDir, "steps", "02-implement");
+  mkdirSync(implementDir, { recursive: true });
+  writeFileSync(join(implementDir, "instruction.md"), getImplementInstruction());
+  writeFileSync(join(implementDir, "template.md"), getImplementTemplate());
+}
+function getPlanInstruction() {
+  return `# Plan Step
+
+You are creating a technical plan for the given task.
+
+## Your Goal
+
+Analyze the user's request and create a detailed implementation plan.
+
+## Process
+
+1. **Understand the Request**
+   - Parse the user's query to identify the core requirements
+   - Identify any ambiguities or missing information
+
+2. **Ask Clarifying Questions** (if needed)
+   - If requirements are unclear, list questions in the \`open_questions\` section
+   - Questions should be specific and actionable
+
+3. **Create the Plan**
+   - Break down the task into concrete steps
+   - Identify files to create/modify
+   - Consider edge cases and potential issues
+
+## Output Format
+
+Follow the template provided. Include:
+- Summary of what will be built
+- Step-by-step implementation plan
+- Files to be created/modified
+- Any open questions (if requirements are unclear)
+`;
+}
+function getPlanTemplate() {
+  return `# Plan: {{title}}
+
+## Summary
+
+Brief description of what will be implemented.
+
+## Requirements
+
+- Requirement 1
+- Requirement 2
+
+## Implementation Steps
+
+### Step 1: [Description]
+
+Details...
+
+### Step 2: [Description]
+
+Details...
+
+## Files to Modify
+
+| File | Action | Description |
+|------|--------|-------------|
+| path/to/file | Create/Modify | What changes |
+
+## Open Questions
+
+<!-- Remove this section if no questions -->
+
+- Question 1?
+- Question 2?
+
+## Risks & Considerations
+
+- Risk 1
+- Risk 2
+`;
+}
+function getImplementInstruction() {
+  return `# Implement Step
+
+You are implementing the plan from the previous step.
+
+## Your Goal
+
+Write the actual code based on the approved plan.
+
+## Process
+
+1. **Review the Plan**
+   - Read the approved plan document carefully
+   - Understand all requirements and steps
+
+2. **Implement**
+   - Follow the plan step by step
+   - Write clean, well-documented code
+   - Handle edge cases identified in the plan
+
+3. **Document Changes**
+   - List all files created/modified
+   - Explain key decisions made during implementation
+
+## Output Format
+
+Follow the template provided. Include:
+- Summary of implementation
+- List of all changes made
+- Any deviations from the plan (with justification)
+- Testing notes
+`;
+}
+function getImplementTemplate() {
+  return `# Implementation: {{title}}
+
+## Summary
+
+Brief description of what was implemented.
+
+## Changes Made
+
+### New Files
+
+| File | Description |
+|------|-------------|
+| path/to/file | What it does |
+
+### Modified Files
+
+| File | Changes |
+|------|---------|
+| path/to/file | What changed |
+
+## Key Decisions
+
+- Decision 1: Explanation
+- Decision 2: Explanation
+
+## Deviations from Plan
+
+<!-- Remove if no deviations -->
+
+None / List any deviations with justification.
+
+## Testing
+
+- [ ] Manual testing completed
+- [ ] Unit tests added
+- [ ] Integration tests pass
+
+## Next Steps
+
+- Follow-up task 1
+- Follow-up task 2
+`;
+}
+function createGitHubWorkflow(cwd) {
+  const workflowDir = join(cwd, ".github", "workflows");
+  mkdirSync(workflowDir, { recursive: true });
+  writeFileSync(join(workflowDir, "sept.yml"), getGitHubWorkflow());
+}
+function getGitHubWorkflow() {
+  const gh = (expr) => `\${{ ${expr} }}`;
+  return `# Spets GitHub Action
+# Runs Claude Code to handle /approve, /revise, /reject commands
+
+name: Spets Workflow
+
+on:
+  issue_comment:
+    types: [created]
+
+jobs:
+  handle-sept-command:
+    # Only run if comment contains a sept command
+    if: |
+      contains(github.event.comment.body, '/approve') ||
+      contains(github.event.comment.body, '/revise') ||
+      contains(github.event.comment.body, '/reject') ||
+      contains(github.event.comment.body, '/answer')
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install Claude Code
+        run: npm install -g @anthropic-ai/claude-code
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Determine context
+        id: context
+        run: |
+          if [ -n "${gh("github.event.issue.pull_request")}" ]; then
+            echo "type=pr" >> $GITHUB_OUTPUT
+          else
+            echo "type=issue" >> $GITHUB_OUTPUT
+          fi
+          echo "number=${gh("github.event.issue.number")}" >> $GITHUB_OUTPUT
+
+      - name: Run Claude Code
+        run: |
+          claude -p "
+          You are running a Spets workflow via GitHub Actions.
+
+          Context:
+          - Repository: ${gh("github.repository")}
+          - Issue/PR: #${gh("github.event.issue.number")}
+          - Comment author: ${gh("github.event.comment.user.login")}
+          - Command received: $COMMENT_BODY
+
+          Instructions:
+          1. Parse the command from the comment (/approve, /revise, /reject, or /answer)
+          2. Find the active sept task in .sept/outputs/
+          3. Execute the appropriate action:
+             - /approve: Mark current step as approved, generate next step
+             - /revise <feedback>: Regenerate current step with feedback
+             - /reject: Mark workflow as rejected
+             - /answer: Process answers and continue
+          4. If generating content (plan or implementation), actually write the code/changes
+          5. Post a summary comment to the PR/Issue using gh cli
+          6. Commit any changes with a descriptive message
+
+          Use 'gh issue comment' or 'gh pr comment' to post updates.
+          "
+        env:
+          COMMENT_BODY: ${gh("github.event.comment.body")}
+          ANTHROPIC_API_KEY: ${gh("secrets.ANTHROPIC_API_KEY")}
+          GH_TOKEN: ${gh("secrets.GITHUB_TOKEN")}
+
+      - name: Push changes
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add -A
+          git diff --staged --quiet || git commit -m "Sept: Update from workflow"
+          git push
+        env:
+          GH_TOKEN: ${gh("secrets.GITHUB_TOKEN")}
+`;
+}
+
+// src/commands/status.ts
+async function statusCommand(options) {
+  const cwd = process.cwd();
+  if (!septExists(cwd)) {
+    console.error('Spets not initialized. Run "spets init" first.');
+    process.exit(1);
+  }
+  const config = loadConfig(cwd);
+  if (options.task) {
+    showTaskStatus(options.task, config, cwd);
+  } else {
+    showAllTasks(config, cwd);
+  }
+}
+function showTaskStatus(taskId, config, cwd) {
+  const state = getWorkflowState(taskId, config, cwd);
+  const meta = loadTaskMetadata(taskId, cwd);
+  if (!state) {
+    console.error(`Task '${taskId}' not found.`);
+    process.exit(1);
+  }
+  console.log(`Task: ${taskId}`);
+  console.log(`Query: ${meta?.userQuery || state.userQuery || "(unknown)"}`);
+  console.log(`Status: ${formatStatus(state.status)}`);
+  console.log(`Current Step: ${state.currentStepName} (${state.currentStepIndex + 1}/${config.steps.length})`);
+  console.log("");
+  console.log("Steps:");
+  for (let i = 0; i < config.steps.length; i++) {
+    const stepName = config.steps[i];
+    const output = state.outputs.get(stepName);
+    const isCurrent = i === state.currentStepIndex;
+    const marker = isCurrent ? "\u2192" : " ";
+    const status = output ? formatDocStatus(output.status) : "\u25CB";
+    console.log(`  ${marker} ${i + 1}. ${stepName} ${status}`);
+  }
+}
+function showAllTasks(config, cwd) {
+  const tasks = listTasks(cwd);
+  if (tasks.length === 0) {
+    console.log("No tasks found.");
+    console.log("");
+    console.log('Start a new task with: sept start "your task description"');
+    return;
+  }
+  console.log("Tasks:");
+  console.log("");
+  for (const taskId of tasks.slice(0, 10)) {
+    const state = getWorkflowState(taskId, config, cwd);
+    const meta = loadTaskMetadata(taskId, cwd);
+    if (!state) continue;
+    const query = meta?.userQuery || state.userQuery || "(no query)";
+    const truncatedQuery = query.length > 50 ? query.substring(0, 47) + "..." : query;
+    const progress = `${state.currentStepIndex + 1}/${config.steps.length}`;
+    console.log(`  ${taskId}  ${formatStatus(state.status)}  [${progress}]`);
+    console.log(`    ${truncatedQuery}`);
+    console.log("");
+  }
+  if (tasks.length > 10) {
+    console.log(`  ... and ${tasks.length - 10} more tasks`);
+  }
+  console.log("");
+  console.log('Use "sept status -t <taskId>" for details');
+}
+function formatStatus(status) {
+  const icons = {
+    in_progress: "\u{1F504} in_progress",
+    completed: "\u2705 completed",
+    paused: "\u23F8\uFE0F  paused",
+    rejected: "\u274C rejected"
+  };
+  return icons[status] || status;
+}
+function formatDocStatus(status) {
+  const icons = {
+    draft: "\u25D0",
+    approved: "\u25CF",
+    rejected: "\u2717"
+  };
+  return icons[status] || "\u25CB";
+}
+
+// src/hooks/runner.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2, isAbsolute } from "path";
+async function runHook(hookPath, context, cwd = process.cwd()) {
+  const resolvedPath = isAbsolute(hookPath) ? hookPath : join2(getSeptDir(cwd), hookPath);
+  if (!existsSync2(resolvedPath)) {
+    console.warn(`Hook not found: ${resolvedPath}`);
+    return;
+  }
+  const env = {
+    ...process.env,
+    SEPT_TASK_ID: context.taskId,
+    SEPT_STEP_NAME: context.stepName,
+    SEPT_STEP_INDEX: String(context.stepIndex),
+    SEPT_OUTPUT_PATH: context.outputPath,
+    SEPT_CWD: cwd
+  };
+  return new Promise((resolve, reject) => {
+    const proc = spawn(resolvedPath, [], {
+      cwd,
+      env,
+      stdio: "inherit",
+      shell: true
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        console.warn(`Hook exited with code ${code}: ${resolvedPath}`);
+      }
+      resolve();
+    });
+    proc.on("error", (err) => {
+      console.warn(`Failed to run hook: ${err.message}`);
+      resolve();
+    });
+  });
+}
+
+// src/core/executor.ts
+var Executor = class {
+  platform;
+  config;
+  cwd;
+  constructor(options) {
+    this.platform = options.platform;
+    this.config = options.config;
+    this.cwd = options.cwd || process.cwd();
+  }
+  async executeWorkflow(taskId, userQuery, startIndex = 0) {
+    let previousOutput;
+    if (startIndex > 0) {
+      const prevStepName = this.config.steps[startIndex - 1];
+      const prevDoc = loadDocument(taskId, prevStepName, this.cwd);
+      if (prevDoc) {
+        previousOutput = prevDoc.content;
+      }
+    }
+    for (let i = startIndex; i < this.config.steps.length; i++) {
+      const stepName = this.config.steps[i];
+      const stepDef = loadStepDefinition(stepName, this.cwd);
+      const context = {
+        taskId,
+        userQuery,
+        stepName,
+        stepIndex: i,
+        instruction: stepDef.instruction,
+        template: stepDef.template,
+        previousOutput,
+        outputPath: getOutputPath(taskId, stepName, this.cwd)
+      };
+      if (this.config.hooks?.preStep) {
+        await runHook(this.config.hooks.preStep, {
+          taskId,
+          stepName,
+          stepIndex: i,
+          outputPath: context.outputPath,
+          document: ""
+        }, this.cwd);
+      }
+      const result = await this.executeStep(context);
+      if (this.config.hooks?.postStep) {
+        await runHook(this.config.hooks.postStep, {
+          taskId,
+          stepName,
+          stepIndex: i,
+          outputPath: context.outputPath,
+          document: result.document
+        }, this.cwd);
+      }
+      if (result.rejected) {
+        console.log("\n\u274C Workflow rejected.");
+        if (this.config.hooks?.onReject) {
+          await runHook(this.config.hooks.onReject, {
+            taskId,
+            stepName,
+            stepIndex: i,
+            outputPath: context.outputPath,
+            document: result.document
+          }, this.cwd);
+        }
+        return;
+      }
+      if (result.paused) {
+        console.log("\n\u23F8\uFE0F  Workflow paused. Resume with: sept resume");
+        return;
+      }
+      if (result.approved) {
+        if (this.config.hooks?.onApprove) {
+          await runHook(this.config.hooks.onApprove, {
+            taskId,
+            stepName,
+            stepIndex: i,
+            outputPath: context.outputPath,
+            document: result.document
+          }, this.cwd);
+        }
+        previousOutput = result.document;
+      }
+    }
+    console.log("\n\u2705 Workflow completed!");
+    if (this.config.hooks?.onComplete) {
+      await runHook(this.config.hooks.onComplete, {
+        taskId,
+        stepName: this.config.steps[this.config.steps.length - 1],
+        stepIndex: this.config.steps.length - 1,
+        outputPath: "",
+        document: previousOutput || ""
+      }, this.cwd);
+    }
+  }
+  async executeStep(context) {
+    let result = await this.platform.generateDocument(context);
+    saveDocument(
+      context.taskId,
+      context.stepName,
+      result.document,
+      "draft",
+      result.questions,
+      this.cwd
+    );
+    while (result.questions.length > 0) {
+      const answers = await this.platform.askUser(result.questions);
+      result = await this.platform.generateDocument({
+        ...context,
+        answers
+      });
+      saveDocument(
+        context.taskId,
+        context.stepName,
+        result.document,
+        "draft",
+        result.questions,
+        this.cwd
+      );
+    }
+    const approval = await this.platform.requestApproval(result.document, context.stepName);
+    if (approval.action === "revise") {
+      return this.executeStep({
+        ...context,
+        feedback: approval.feedback
+      });
+    }
+    const outputPath = getOutputPath(context.taskId, context.stepName, this.cwd);
+    if (approval.action === "approve") {
+      updateDocumentStatus(outputPath, "approved");
+    } else if (approval.action === "reject") {
+      updateDocumentStatus(outputPath, "rejected");
+    }
+    return {
+      document: result.document,
+      approved: approval.action === "approve",
+      rejected: approval.action === "reject",
+      paused: approval.action === "pause"
+    };
+  }
+};
+
+// src/platform/cli.ts
+import { spawn as spawn2 } from "child_process";
+import { input, select, confirm } from "@inquirer/prompts";
+
+// src/platform/interface.ts
+var BasePlatform = class {
+};
+
+// src/platform/cli.ts
+var CliPlatform = class extends BasePlatform {
+  claudeCommand;
+  constructor(claudeCommand = "claude") {
+    super();
+    this.claudeCommand = claudeCommand;
+  }
+  async generateDocument(context) {
+    const prompt = this.buildPrompt(context);
+    console.log(`
+\u{1F4DD} Generating ${context.stepName}...`);
+    const response = await this.callClaude(prompt);
+    const { document, questions } = this.parseResponse(response);
+    return { document, questions };
+  }
+  async askUser(questions) {
+    const answers = [];
+    console.log("\n\u2753 Please answer the following questions:\n");
+    for (const q of questions) {
+      if (q.context) {
+        console.log(`Context: ${q.context}`);
+      }
+      const answer = await input({
+        message: q.question
+      });
+      answers.push({
+        questionId: q.id,
+        answer
+      });
+      console.log("");
+    }
+    return answers;
+  }
+  async requestApproval(doc, stepName) {
+    console.log("\n" + "=".repeat(60));
+    console.log(`\u{1F4C4} ${stepName} Document`);
+    console.log("=".repeat(60));
+    console.log(doc);
+    console.log("=".repeat(60) + "\n");
+    const action = await select({
+      message: "What would you like to do?",
+      choices: [
+        { value: "approve", name: "\u2705 Approve - Continue to next step" },
+        { value: "revise", name: "\u270F\uFE0F  Revise - Request changes" },
+        { value: "reject", name: "\u274C Reject - Stop workflow" },
+        { value: "pause", name: "\u23F8\uFE0F  Pause - Save and exit" }
+      ]
+    });
+    if (action === "revise") {
+      const feedback = await input({
+        message: "What changes would you like?"
+      });
+      return { action: "revise", feedback };
+    }
+    if (action === "reject") {
+      const confirmed = await confirm({
+        message: "Are you sure you want to reject? This will stop the workflow.",
+        default: false
+      });
+      if (!confirmed) {
+        return this.requestApproval(doc, stepName);
+      }
+    }
+    return { action };
+  }
+  buildPrompt(context) {
+    const parts = [];
+    parts.push("# Task");
+    parts.push(`You are executing step "${context.stepName}" of a spec-driven development workflow.`);
+    parts.push("");
+    parts.push("## User Query");
+    parts.push(context.userQuery);
+    parts.push("");
+    parts.push("## Step Instructions");
+    parts.push(context.instruction);
+    parts.push("");
+    if (context.template) {
+      parts.push("## Output Template");
+      parts.push("Follow this template structure:");
+      parts.push(context.template);
+      parts.push("");
+    }
+    if (context.previousOutput) {
+      parts.push("## Previous Step Output");
+      parts.push(context.previousOutput);
+      parts.push("");
+    }
+    if (context.answers && context.answers.length > 0) {
+      parts.push("## Answers to Questions");
+      for (const a of context.answers) {
+        parts.push(`- ${a.questionId}: ${a.answer}`);
+      }
+      parts.push("");
+    }
+    if (context.feedback) {
+      parts.push("## Revision Feedback");
+      parts.push(context.feedback);
+      parts.push("");
+    }
+    parts.push("## Output Format");
+    parts.push("Generate the document content.");
+    parts.push("If you have clarifying questions, include them at the end in this format:");
+    parts.push("```questions");
+    parts.push("Q1: [Your question here]");
+    parts.push("Q2: [Another question if needed]");
+    parts.push("```");
+    parts.push("");
+    parts.push("Only ask questions if absolutely necessary for the task.");
+    return parts.join("\n");
+  }
+  async callClaude(prompt) {
+    return new Promise((resolve, reject) => {
+      const proc = spawn2(this.claudeCommand, ["-p", prompt], {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+        process.stdout.write(data);
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        if (code !== 0) {
+          reject(new Error(`Claude CLI exited with code ${code}: ${stderr}`));
+        } else {
+          resolve(stdout);
+        }
+      });
+      proc.on("error", (err) => {
+        reject(new Error(`Failed to run Claude CLI: ${err.message}`));
+      });
+    });
+  }
+  parseResponse(response) {
+    const questions = [];
+    const questionMatch = response.match(/```questions\n([\s\S]*?)```/);
+    if (questionMatch) {
+      const questionsText = questionMatch[1];
+      const questionLines = questionsText.split("\n").filter((l) => l.trim());
+      for (const line of questionLines) {
+        const match = line.match(/^Q(\d+):\s*(.+)$/);
+        if (match) {
+          questions.push({
+            id: `q${match[1]}`,
+            question: match[2].trim()
+          });
+        }
+      }
+    }
+    const document = response.replace(/```questions\n[\s\S]*?```\n?/, "").trim();
+    return { document, questions };
+  }
+};
+
+// src/platform/github.ts
+import { spawn as spawn3 } from "child_process";
+var PauseForInputError = class extends Error {
+  constructor(inputType, data) {
+    super(`Paused waiting for ${inputType}`);
+    this.inputType = inputType;
+    this.data = data;
+    this.name = "PauseForInputError";
+  }
+};
+function parseGitHubCommand(comment) {
+  const trimmed = comment.trim();
+  if (trimmed === "/approve") {
+    return { command: "approve" };
+  }
+  if (trimmed === "/reject") {
+    return { command: "reject" };
+  }
+  const reviseMatch = trimmed.match(/^\/revise\s+(.+)$/s);
+  if (reviseMatch) {
+    return { command: "revise", feedback: reviseMatch[1].trim() };
+  }
+  const answerMatch = trimmed.match(/^\/answer\s*\n([\s\S]+)$/m);
+  if (answerMatch) {
+    const answersText = answerMatch[1];
+    const answers = {};
+    const answerLines = answersText.split("\n");
+    for (const line of answerLines) {
+      const match = line.match(/^(Q\d+):\s*(.+)$/i);
+      if (match) {
+        answers[match[1].toLowerCase()] = match[2].trim();
+      }
+    }
+    return { command: "answer", answers };
+  }
+  return { command: null };
+}
+var GitHubPlatform = class extends BasePlatform {
+  config;
+  currentTaskId;
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  setTaskId(taskId) {
+    this.currentTaskId = taskId;
+  }
+  async generateDocument(context) {
+    this.currentTaskId = context.taskId;
+    const prompt = this.buildPrompt(context);
+    const response = await this.callClaude(prompt);
+    const { document, questions } = this.parseResponse(response);
+    return { document, questions };
+  }
+  async askUser(questions) {
+    const comment = this.formatQuestionsComment(questions, this.currentTaskId);
+    await this.postComment(comment);
+    console.log("\n\u23F8\uFE0F  Waiting for answers on GitHub...");
+    console.log("   The workflow will resume when questions are answered.");
+    throw new PauseForInputError("questions", questions);
+  }
+  async requestApproval(doc, stepName) {
+    const comment = this.formatApprovalComment(doc, stepName, this.currentTaskId);
+    await this.postComment(comment);
+    console.log("\n\u23F8\uFE0F  Waiting for approval on GitHub...");
+    console.log("   Comment /approve, /revise <feedback>, or /reject on the PR/Issue.");
+    return { action: "pause" };
+  }
+  async postComment(body) {
+    if (this.config.prNumber) {
+      await this.postPRComment(body);
+    } else if (this.config.issueNumber) {
+      await this.postIssueComment(body);
+    } else {
+      throw new Error("Either prNumber or issueNumber must be specified");
+    }
+  }
+  formatQuestionsComment(questions, taskId) {
+    const lines = [
+      "## \u{1F4CB} Sept: Questions Need Answers",
+      "",
+      `> Task ID: \`${taskId}\``,
+      "",
+      "Please answer the following questions:",
+      ""
+    ];
+    for (let i = 0; i < questions.length; i++) {
+      const q = questions[i];
+      lines.push(`### Q${i + 1}: ${q.question}`);
+      if (q.context) {
+        lines.push(`> ${q.context}`);
+      }
+      lines.push("");
+    }
+    lines.push("---");
+    lines.push("**Reply with:**");
+    lines.push("```");
+    lines.push("/answer");
+    for (let i = 0; i < questions.length; i++) {
+      lines.push(`Q${i + 1}: your answer here`);
+    }
+    lines.push("```");
+    return lines.join("\n");
+  }
+  formatApprovalComment(doc, stepName, taskId) {
+    const lines = [
+      `## \u{1F4C4} Sept: ${stepName} - Review Required`,
+      "",
+      `> Task ID: \`${taskId}\``,
+      "",
+      "<details>",
+      "<summary>\u{1F4DD} View Document</summary>",
+      "",
+      "```markdown",
+      doc,
+      "```",
+      "",
+      "</details>",
+      "",
+      "---",
+      "",
+      "**Commands:**",
+      "| Command | Description |",
+      "|---------|-------------|",
+      "| `/approve` | Approve and continue to next step |",
+      "| `/revise <feedback>` | Request changes with feedback |",
+      "| `/reject` | Reject and stop workflow |"
+    ];
+    return lines.join("\n");
+  }
+  async postPRComment(body) {
+    const { owner, repo, prNumber } = this.config;
+    await this.runGh(["pr", "comment", String(prNumber), "--body", body, "-R", `${owner}/${repo}`]);
+  }
+  async postIssueComment(body) {
+    const { owner, repo, issueNumber } = this.config;
+    await this.runGh(["issue", "comment", String(issueNumber), "--body", body, "-R", `${owner}/${repo}`]);
+  }
+  async runGh(args) {
+    return new Promise((resolve, reject) => {
+      const proc = spawn3("gh", args, { stdio: ["pipe", "pipe", "pipe"] });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        if (code !== 0) {
+          reject(new Error(`gh command failed: ${stderr}`));
+        } else {
+          resolve(stdout);
+        }
+      });
+      proc.on("error", (err) => {
+        reject(new Error(`Failed to run gh: ${err.message}`));
+      });
+    });
+  }
+  buildPrompt(context) {
+    const parts = [];
+    parts.push("# Task");
+    parts.push(`You are executing step "${context.stepName}" of a spec-driven development workflow.`);
+    parts.push("");
+    parts.push("## User Query");
+    parts.push(context.userQuery);
+    parts.push("");
+    parts.push("## Step Instructions");
+    parts.push(context.instruction);
+    if (context.template) {
+      parts.push("");
+      parts.push("## Output Template");
+      parts.push(context.template);
+    }
+    if (context.previousOutput) {
+      parts.push("");
+      parts.push("## Previous Step Output");
+      parts.push(context.previousOutput);
+    }
+    if (context.feedback) {
+      parts.push("");
+      parts.push("## Revision Feedback");
+      parts.push(context.feedback);
+    }
+    return parts.join("\n");
+  }
+  async callClaude(prompt) {
+    return new Promise((resolve, reject) => {
+      const proc = spawn3("claude", ["-p", prompt], { stdio: ["pipe", "pipe", "pipe"] });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        if (code !== 0) {
+          reject(new Error(`Claude CLI failed: ${stderr}`));
+        } else {
+          resolve(stdout);
+        }
+      });
+      proc.on("error", (err) => {
+        reject(new Error(`Failed to run Claude: ${err.message}`));
+      });
+    });
+  }
+  parseResponse(response) {
+    const questions = [];
+    const questionMatch = response.match(/```questions\n([\s\S]*?)```/);
+    if (questionMatch) {
+      const questionsText = questionMatch[1];
+      const questionLines = questionsText.split("\n").filter((l) => l.trim());
+      for (const line of questionLines) {
+        const match = line.match(/^Q(\d+):\s*(.+)$/);
+        if (match) {
+          questions.push({
+            id: `q${match[1]}`,
+            question: match[2].trim()
+          });
+        }
+      }
+    }
+    const document = response.replace(/```questions\n[\s\S]*?```\n?/, "").trim();
+    return { document, questions };
+  }
+};
+
+// src/commands/start.ts
+async function startCommand(query, options) {
+  const cwd = process.cwd();
+  if (!septExists(cwd)) {
+    console.error('Spets not initialized. Run "spets init" first.');
+    process.exit(1);
+  }
+  const config = loadConfig(cwd);
+  const taskId = generateTaskId();
+  console.log(`Starting new workflow: ${taskId}`);
+  console.log(`Query: ${query}`);
+  console.log(`Platform: ${options.platform || "cli"}`);
+  console.log("");
+  saveTaskMetadata(taskId, query, cwd);
+  let platform;
+  if (options.platform === "github") {
+    if (!options.owner || !options.repo) {
+      console.error("GitHub platform requires --owner and --repo");
+      process.exit(1);
+    }
+    if (!options.pr && !options.issue) {
+      console.error("GitHub platform requires --pr or --issue");
+      process.exit(1);
+    }
+    platform = new GitHubPlatform({
+      owner: options.owner,
+      repo: options.repo,
+      prNumber: options.pr ? parseInt(options.pr, 10) : void 0,
+      issueNumber: options.issue ? parseInt(options.issue, 10) : void 0
+    });
+  } else {
+    platform = new CliPlatform();
+  }
+  const executor = new Executor({ platform, config, cwd });
+  try {
+    await executor.executeWorkflow(taskId, query);
+  } catch (error) {
+    if (error instanceof PauseForInputError) {
+      console.log("\nWorkflow paused. Waiting for GitHub input.");
+      console.log(`Task ID: ${taskId}`);
+      return;
+    }
+    console.error("Workflow failed:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+
+// src/commands/resume.ts
+import { select as select2 } from "@inquirer/prompts";
+async function resumeCommand(options) {
+  const cwd = process.cwd();
+  if (!septExists(cwd)) {
+    console.error('Spets not initialized. Run "spets init" first.');
+    process.exit(1);
+  }
+  const config = loadConfig(cwd);
+  let taskId = options.task;
+  if (!taskId) {
+    const tasks = listTasks(cwd);
+    const resumableTasks = [];
+    for (const tid of tasks) {
+      const state2 = getWorkflowState(tid, config, cwd);
+      const meta2 = loadTaskMetadata(tid, cwd);
+      if (state2 && (state2.status === "in_progress" || state2.status === "paused")) {
+        resumableTasks.push({
+          taskId: tid,
+          query: meta2?.userQuery || state2.userQuery || "(unknown)",
+          status: state2.status
+        });
+      }
+    }
+    if (resumableTasks.length === 0) {
+      console.log("No tasks to resume.");
+      console.log('Start a new task with: sept start "your task description"');
+      return;
+    }
+    if (resumableTasks.length === 1) {
+      taskId = resumableTasks[0].taskId;
+    } else {
+      taskId = await select2({
+        message: "Select task to resume:",
+        choices: resumableTasks.map((t) => ({
+          value: t.taskId,
+          name: `${t.taskId} [${t.status}] - ${t.query.substring(0, 50)}${t.query.length > 50 ? "..." : ""}`
+        }))
+      });
+    }
+  }
+  const state = getWorkflowState(taskId, config, cwd);
+  const meta = loadTaskMetadata(taskId, cwd);
+  if (!state) {
+    console.error(`Task '${taskId}' not found.`);
+    process.exit(1);
+  }
+  if (state.status === "completed") {
+    console.log("Task already completed.");
+    return;
+  }
+  if (state.status === "rejected") {
+    console.log("Task was rejected. Cannot resume.");
+    return;
+  }
+  const userQuery = meta?.userQuery || state.userQuery || "";
+  console.log(`Resuming task: ${taskId}`);
+  console.log(`Query: ${userQuery}`);
+  console.log(`Current step: ${state.currentStepName}`);
+  console.log("");
+  if (options.approve) {
+    const outputPath = getOutputPath(taskId, state.currentStepName, cwd);
+    updateDocumentStatus(outputPath, "approved");
+    console.log(`Approved: ${state.currentStepName}`);
+    const nextIndex = state.currentStepIndex + 1;
+    if (nextIndex >= config.steps.length) {
+      console.log("\n\u2705 Workflow completed!");
+      return;
+    }
+    const platform2 = new CliPlatform();
+    const executor2 = new Executor({ platform: platform2, config, cwd });
+    await executor2.executeWorkflow(taskId, userQuery, nextIndex);
+    return;
+  }
+  if (options.revise) {
+    const platform2 = new CliPlatform();
+    const executor2 = new Executor({ platform: platform2, config, cwd });
+    console.log(`Revising with feedback: ${options.revise}`);
+    await executor2.executeWorkflow(taskId, userQuery, state.currentStepIndex);
+    return;
+  }
+  const platform = new CliPlatform();
+  const executor = new Executor({ platform, config, cwd });
+  await executor.executeWorkflow(taskId, userQuery, state.currentStepIndex);
+}
+
+// src/commands/plugin.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, rmSync } from "fs";
+import { join as join3 } from "path";
+import { homedir } from "os";
+async function pluginCommand(action, name) {
+  switch (action) {
+    case "install":
+      if (!name) {
+        console.error("Plugin name required.");
+        console.error("Usage: spets plugin install <name>");
+        process.exit(1);
+      }
+      await installPlugin(name);
+      break;
+    case "uninstall":
+      if (!name) {
+        console.error("Plugin name required.");
+        console.error("Usage: spets plugin uninstall <name>");
+        process.exit(1);
+      }
+      await uninstallPlugin(name);
+      break;
+    case "list":
+      await listPlugins();
+      break;
+    default:
+      console.error(`Unknown action: ${action}`);
+      console.error("Available actions: install, uninstall, list");
+      process.exit(1);
+  }
+}
+async function installPlugin(name) {
+  const plugins = {
+    claude: installClaudePlugin
+  };
+  const installer = plugins[name];
+  if (!installer) {
+    console.error(`Unknown plugin: ${name}`);
+    console.error("Available plugins: claude");
+    process.exit(1);
+  }
+  installer();
+}
+function installClaudePlugin() {
+  const claudeDir = join3(homedir(), ".claude");
+  const commandsDir = join3(claudeDir, "commands");
+  mkdirSync2(commandsDir, { recursive: true });
+  const skillPath = join3(commandsDir, "spets.md");
+  writeFileSync2(skillPath, getClaudeSkillContent());
+  console.log("Installed Claude Code plugin.");
+  console.log(`Location: ${skillPath}`);
+  console.log("");
+  console.log("Usage in Claude Code:");
+  console.log('  /spets start "your task description"');
+  console.log("  /spets status");
+  console.log("  /spets resume");
+}
+async function uninstallPlugin(name) {
+  if (name === "claude") {
+    const skillPath = join3(homedir(), ".claude", "commands", "spets.md");
+    if (existsSync3(skillPath)) {
+      rmSync(skillPath);
+      console.log("Uninstalled Claude Code plugin.");
+    } else {
+      console.log("Claude Code plugin not installed.");
+    }
+    return;
+  }
+  console.error(`Unknown plugin: ${name}`);
+  process.exit(1);
+}
+async function listPlugins() {
+  console.log("Available plugins:");
+  console.log("");
+  console.log("  claude - Claude Code slash command integration");
+  console.log("");
+  const claudeSkillPath = join3(homedir(), ".claude", "commands", "spets.md");
+  const claudeInstalled = existsSync3(claudeSkillPath);
+  console.log("Installed:");
+  if (claudeInstalled) {
+    console.log("  - claude");
+  } else {
+    console.log("  (none)");
+  }
+}
+function getClaudeSkillContent() {
+  return `# Spets - Spec Driven Development
+
+Run spets workflows from Claude Code.
+
+## Usage
+
+\`\`\`
+/spets start "task description"  - Start a new workflow
+/spets status                     - Show workflow status
+/spets resume                     - Resume paused workflow
+\`\`\`
+
+## Instructions
+
+When the user invokes this command:
+
+1. Parse the subcommand (start, status, resume)
+2. Execute the appropriate spets CLI command using Bash
+3. For 'start', read the generated documents and help iterate
+
+### Start Flow
+
+1. Run: \`spets start "<query>"\`
+2. Read the generated plan document from .sept/outputs/<taskId>/
+3. Present the plan to the user
+4. If user approves, continue. If they want changes, provide feedback.
+
+### Status Flow
+
+1. Run: \`spets status\`
+2. Present the current workflow state
+
+### Resume Flow
+
+1. Run: \`spets resume\`
+2. Continue the workflow from where it paused
+
+## Example Session
+
+User: /spets start "Create a REST API for user management"
+
+Claude:
+1. Runs \`spets start "Create a REST API for user management"\`
+2. Reads the generated plan
+3. Asks user: "Here's the plan. [shows plan] Would you like to approve or revise?"
+4. On approve: \`spets resume --approve\`
+5. On revise: \`spets resume --revise "user feedback"\`
+
+$ARGUMENTS
+command: The spets command to run (start, status, resume)
+args: Additional arguments for the command
+`;
+}
+
+// src/commands/github.ts
+async function githubCommand(options) {
+  const cwd = process.cwd();
+  if (!septExists(cwd)) {
+    console.error("Spets not initialized.");
+    process.exit(1);
+  }
+  const { owner, repo, pr, issue, comment, task } = options;
+  if (!pr && !issue) {
+    console.error("Either --pr or --issue is required");
+    process.exit(1);
+  }
+  const parsed = parseGitHubCommand(comment);
+  if (!parsed.command) {
+    console.log("No sept command found in comment. Ignoring.");
+    return;
+  }
+  console.log(`Received command: ${parsed.command}`);
+  let taskId = task;
+  if (!taskId) {
+    const taskMatch = comment.match(/Task ID: `([^`]+)`/);
+    if (taskMatch) {
+      taskId = taskMatch[1];
+    }
+  }
+  if (!taskId) {
+    const config2 = loadConfig(cwd);
+    const { listTasks: listTasks2 } = await import("./state-MCFJFWJC.js");
+    const tasks = listTasks2(cwd);
+    for (const tid of tasks) {
+      const state2 = getWorkflowState(tid, config2, cwd);
+      if (state2 && (state2.status === "in_progress" || state2.status === "paused")) {
+        taskId = tid;
+        break;
+      }
+    }
+  }
+  if (!taskId) {
+    console.error("Could not determine task ID. Use --task option.");
+    process.exit(1);
+  }
+  const config = loadConfig(cwd);
+  const state = getWorkflowState(taskId, config, cwd);
+  const meta = loadTaskMetadata(taskId, cwd);
+  if (!state) {
+    console.error(`Task '${taskId}' not found.`);
+    process.exit(1);
+  }
+  const userQuery = meta?.userQuery || state.userQuery || "";
+  const outputPath = getOutputPath(taskId, state.currentStepName, cwd);
+  const githubConfig = {
+    owner,
+    repo,
+    prNumber: pr ? parseInt(pr, 10) : void 0,
+    issueNumber: issue ? parseInt(issue, 10) : void 0
+  };
+  switch (parsed.command) {
+    case "approve": {
+      console.log(`Approving step: ${state.currentStepName}`);
+      updateDocumentStatus(outputPath, "approved");
+      const nextIndex = state.currentStepIndex + 1;
+      if (nextIndex >= config.steps.length) {
+        console.log("\u2705 Workflow completed!");
+        await postCompletionComment(githubConfig, taskId);
+        return;
+      }
+      const platform = new GitHubPlatform(githubConfig);
+      const executor = new Executor({ platform, config, cwd });
+      try {
+        await executor.executeWorkflow(taskId, userQuery, nextIndex);
+      } catch (error) {
+        if (error.name !== "PauseForInputError") {
+          throw error;
+        }
+      }
+      break;
+    }
+    case "revise": {
+      console.log(`Revising step with feedback: ${parsed.feedback}`);
+      const platform = new GitHubPlatform(githubConfig);
+      const executor = new Executor({ platform, config, cwd });
+      try {
+        await executor.executeWorkflow(taskId, userQuery, state.currentStepIndex);
+      } catch (error) {
+        if (error.name !== "PauseForInputError") {
+          throw error;
+        }
+      }
+      break;
+    }
+    case "reject": {
+      console.log("Rejecting workflow");
+      updateDocumentStatus(outputPath, "rejected");
+      await postRejectionComment(githubConfig, taskId, state.currentStepName);
+      break;
+    }
+    case "answer": {
+      console.log("Processing answers");
+      const doc = loadDocument(taskId, state.currentStepName, cwd);
+      if (!doc?.frontmatter.open_questions?.length) {
+        console.log("No open questions for this task.");
+        return;
+      }
+      const answers = Object.entries(parsed.answers || {}).map(([id, answer], index) => ({
+        questionId: id,
+        answer
+      }));
+      const platform = new GitHubPlatform(githubConfig);
+      const executor = new Executor({ platform, config, cwd });
+      try {
+        await executor.executeWorkflow(taskId, userQuery, state.currentStepIndex);
+      } catch (error) {
+        if (error.name !== "PauseForInputError") {
+          throw error;
+        }
+      }
+      break;
+    }
+  }
+}
+async function postCompletionComment(config, taskId) {
+  const comment = [
+    "## \u2705 Spets Workflow Completed",
+    "",
+    `Task \`${taskId}\` has been completed successfully!`,
+    "",
+    "All steps have been approved."
+  ].join("\n");
+  await postComment(config, comment);
+}
+async function postRejectionComment(config, taskId, stepName) {
+  const comment = [
+    "## \u274C Spets Workflow Rejected",
+    "",
+    `Task \`${taskId}\` was rejected at step: **${stepName}**`
+  ].join("\n");
+  await postComment(config, comment);
+}
+async function postComment(config, body) {
+  const { spawn: spawn4 } = await import("child_process");
+  const { owner, repo, prNumber, issueNumber } = config;
+  const args = prNumber ? ["pr", "comment", String(prNumber), "--body", body, "-R", `${owner}/${repo}`] : ["issue", "comment", String(issueNumber), "--body", body, "-R", `${owner}/${repo}`];
+  return new Promise((resolve, reject) => {
+    const proc = spawn4("gh", args, { stdio: "inherit" });
+    proc.on("close", (code) => {
+      if (code !== 0) reject(new Error(`gh failed with code ${code}`));
+      else resolve();
+    });
+    proc.on("error", reject);
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("spets").description("Spec Driven Development Execution Framework").version("0.1.0");
+program.command("init").description("Initialize sept in current directory").option("-f, --force", "Overwrite existing config").option("--github", "Add GitHub Actions workflow for PR/Issue integration").action(initCommand);
+program.command("status").description("Show current workflow status").option("-t, --task <taskId>", "Show status for specific task").action(statusCommand);
+program.command("start").description("Start a new workflow").argument("<query>", "User query describing the task").option("-p, --platform <platform>", "Platform to use (cli, github)", "cli").option("--owner <owner>", "GitHub owner (for github platform)").option("--repo <repo>", "GitHub repo (for github platform)").option("--pr <number>", "GitHub PR number (for github platform)").option("--issue <number>", "GitHub issue number (for github platform)").action(startCommand);
+program.command("resume").description("Resume paused workflow").option("-t, --task <taskId>", "Resume specific task").option("--approve", "Approve current document and proceed").option("--revise <feedback>", "Request revision with feedback").action(resumeCommand);
+program.command("github").description("Handle GitHub Action callback (internal)").requiredOption("--owner <owner>", "GitHub owner").requiredOption("--repo <repo>", "GitHub repo").option("--pr <number>", "PR number").option("--issue <number>", "Issue number").option("-t, --task <taskId>", "Task ID").requiredOption("--comment <comment>", "Comment body").action(githubCommand);
+program.command("plugin").description("Manage plugins").argument("<action>", "Action: install, uninstall, list").argument("[name]", "Plugin name").action(pluginCommand);
+program.parse();