spets 0.1.7 → 0.1.9

package/dist/{chunk-YK5ZZE4P.js → chunk-NOS3N4GT.js}

@@ -10,6 +10,9 @@ import { parse as parseYaml } from "yaml";
 var SPETS_DIR = ".spets";
 var CONFIG_FILE = "config.yml";
 var STEPS_DIR = "steps";
+var configCache = null;
+var configCachePath = null;
+var stepDefinitionCache = /* @__PURE__ */ new Map();
 function getSpetsDir(cwd = process.cwd()) {
   return join(cwd, SPETS_DIR);
 }
@@ -27,6 +30,9 @@ function spetsExists(cwd = process.cwd()) {
 }
 function loadConfig(cwd = process.cwd()) {
   const configPath = getConfigPath(cwd);
+  if (configCache && configCachePath === configPath) {
+    return configCache;
+  }
   if (!existsSync(configPath)) {
     throw new Error(`Spets config not found. Run 'spets init' first.`);
   }
@@ -35,9 +41,15 @@ function loadConfig(cwd = process.cwd()) {
   if (!config.steps || config.steps.length === 0) {
     throw new Error("Config must define at least one step");
   }
+  configCache = config;
+  configCachePath = configPath;
   return config;
 }
 function loadStepDefinition(stepName, cwd = process.cwd()) {
+  const cacheKey = `${cwd}:${stepName}`;
+  if (stepDefinitionCache.has(cacheKey)) {
+    return stepDefinitionCache.get(cacheKey);
+  }
   const stepDir = join(getStepsDir(cwd), stepName);
   const instructionPath = join(stepDir, "instruction.md");
   const templatePath = join(stepDir, "template.md");
@@ -46,19 +58,58 @@ function loadStepDefinition(stepName, cwd = process.cwd()) {
   }
   const instruction = readFileSync(instructionPath, "utf-8");
   const template = existsSync(templatePath) ? readFileSync(templatePath, "utf-8") : void 0;
-  return {
+  const stepDef = {
     name: stepName,
     instruction,
     template
   };
+  stepDefinitionCache.set(cacheKey, stepDef);
+  return stepDef;
 }
 function getGitHubConfig(cwd = process.cwd()) {
   const config = loadConfig(cwd);
   return config.github;
 }
 
+// src/core/slug.ts
+function generateRandomSuffix() {
+  return Math.random().toString(36).substring(2, 6);
+}
+function generateDatePrefix() {
+  const now = /* @__PURE__ */ new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function sanitizeDescription(description) {
+  let sanitized = description.toLowerCase();
+  sanitized = sanitized.replace(/[^\x00-\x7F]/g, "");
+  sanitized = sanitized.replace(/[^a-z0-9\s]/g, "");
+  sanitized = sanitized.trim();
+  sanitized = sanitized.replace(/\s+/g, " ");
+  sanitized = sanitized.replace(/\s+/g, "-");
+  if (sanitized.length > 10) {
+    sanitized = sanitized.substring(0, 10);
+  }
+  sanitized = sanitized.replace(/-+$/, "");
+  if (sanitized === "") {
+    sanitized = "task";
+  }
+  return sanitized;
+}
+function generateSlug(description) {
+  const datePrefix = generateDatePrefix();
+  const meaningfulName = sanitizeDescription(description);
+  const randomSuffix = generateRandomSuffix();
+  return `${datePrefix}-${meaningfulName}-${randomSuffix}`;
+}
+
 // src/core/state.ts
-function generateTaskId() {
+function generateTaskId(description) {
+  if (description) {
+    return generateSlug(description);
+  }
   const timestamp = Date.now().toString(36);
   const random = Math.random().toString(36).substring(2, 6);
   return `${timestamp}-${random}`;
@@ -132,11 +183,68 @@ function listTasks(cwd = process.cwd()) {
   }
   return readdirSync(outputsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
 }
+function getStateCachePath(taskId, cwd = process.cwd()) {
+  return join2(getTaskDir(taskId, cwd), ".state-cache.json");
+}
+function loadStateCache(taskId, cwd = process.cwd()) {
+  const cachePath = getStateCachePath(taskId, cwd);
+  if (!existsSync2(cachePath)) {
+    return null;
+  }
+  try {
+    const cached = JSON.parse(readFileSync2(cachePath, "utf-8"));
+    return cached;
+  } catch {
+    return null;
+  }
+}
+function saveStateCache(taskId, state, cwd = process.cwd()) {
+  const cachePath = getStateCachePath(taskId, cwd);
+  const stepStatuses = {};
+  for (const [stepName, output] of state.outputs.entries()) {
+    stepStatuses[stepName] = output.status;
+  }
+  const cached = {
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    taskId: state.taskId,
+    userQuery: state.userQuery,
+    currentStepIndex: state.currentStepIndex,
+    currentStepName: state.currentStepName,
+    status: state.status,
+    stepStatuses
+  };
+  try {
+    writeFileSync(cachePath, JSON.stringify(cached, null, 2));
+  } catch {
+  }
+}
+function isStateCacheValid(cached, maxAgeMs = 5e3) {
+  const age = Date.now() - new Date(cached.lastUpdated).getTime();
+  return age < maxAgeMs;
+}
 function getWorkflowState(taskId, config, cwd = process.cwd()) {
   const taskDir = getTaskDir(taskId, cwd);
   if (!existsSync2(taskDir)) {
     return null;
   }
+  const cached = loadStateCache(taskId, cwd);
+  if (cached && isStateCacheValid(cached)) {
+    const outputs2 = /* @__PURE__ */ new Map();
+    for (const [stepName, status] of Object.entries(cached.stepStatuses)) {
+      outputs2.set(stepName, {
+        path: getOutputPath(taskId, stepName, cwd),
+        status
+      });
+    }
+    return {
+      taskId: cached.taskId,
+      userQuery: cached.userQuery,
+      currentStepIndex: cached.currentStepIndex,
+      currentStepName: cached.currentStepName,
+      status: cached.status,
+      outputs: outputs2
+    };
+  }
   const outputs = /* @__PURE__ */ new Map();
   let lastApprovedIndex = -1;
   let currentStatus = "in_progress";
@@ -171,7 +279,7 @@ function getWorkflowState(taskId, config, cwd = process.cwd()) {
   if (currentDoc?.frontmatter.status === "draft" && currentDoc.frontmatter.open_questions?.length) {
     currentStatus = "paused";
   }
-  return {
+  const state = {
     taskId,
     userQuery,
     currentStepIndex,
@@ -179,6 +287,8 @@ function getWorkflowState(taskId, config, cwd = process.cwd()) {
     status: currentStatus,
     outputs
   };
+  saveStateCache(taskId, state, cwd);
+  return state;
 }
 function saveTaskMetadata(taskId, userQuery, cwd = process.cwd()) {
   const taskDir = ensureTaskDir(taskId, cwd);
@@ -192,6 +302,21 @@ function loadTaskMetadata(taskId, cwd = process.cwd()) {
   }
   return JSON.parse(readFileSync2(metaPath, "utf-8"));
 }
+function extractPlanSummary(taskId, cwd = process.cwd()) {
+  const doc = loadDocument(taskId, "01-plan", cwd);
+  if (!doc) {
+    return null;
+  }
+  const summaryMatch = doc.content.match(/## Summary\n\n(.+?)(?=\n\n##|\n\n$|$)/s);
+  if (summaryMatch) {
+    return summaryMatch[1].trim();
+  }
+  const goalMatch = doc.content.match(/## Goal\n\n(.+?)(?=\n\n##|\n\n$|$)/s);
+  if (goalMatch) {
+    return goalMatch[1].trim();
+  }
+  return null;
+}
 
 export {
   getSpetsDir,
@@ -213,5 +338,6 @@ export {
   listTasks,
   getWorkflowState,
   saveTaskMetadata,
-  loadTaskMetadata
+  loadTaskMetadata,
+  extractPlanSummary
 };

package/dist/index.js

@@ -16,13 +16,13 @@ import {
   saveTaskMetadata,
   spetsExists,
   updateDocumentStatus
-} from "./chunk-YK5ZZE4P.js";
+} from "./chunk-NOS3N4GT.js";
 
 // src/index.ts
 import { Command } from "commander";
 
 // src/commands/init.ts
-import { mkdirSync, writeFileSync } from "fs";
+import { mkdirSync, writeFileSync, readFileSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { execSync } from "child_process";
@@ -121,155 +121,20 @@ function createDefaultSteps(spetsDir) {
   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)
-`;
+  const fullTemplate = readFileSync(join(__dirname, "..", ".spets", "steps", "01-plan", "instruction.md"), "utf-8");
+  return fullTemplate;
 }
 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
-`;
+  const fullTemplate = readFileSync(join(__dirname, "..", ".spets", "steps", "01-plan", "template.md"), "utf-8");
+  return fullTemplate;
 }
 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
-`;
+  const fullTemplate = readFileSync(join(__dirname, "..", ".spets", "steps", "02-implement", "instruction.md"), "utf-8");
+  return fullTemplate;
 }
 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
-`;
+  const fullTemplate = readFileSync(join(__dirname, "..", ".spets", "steps", "02-implement", "template.md"), "utf-8");
+  return fullTemplate;
 }
 function createClaudeCommand(cwd) {
   const commandDir = join(cwd, ".claude", "commands");
@@ -702,6 +567,16 @@ var Executor = class {
     this.config = options.config;
     this.cwd = options.cwd || process.cwd();
   }
+  /**
+   * Preload all step definitions into cache for better performance
+   */
+  async preloadSteps() {
+    await Promise.all(
+      this.config.steps.map(
+        (stepName) => Promise.resolve(loadStepDefinition(stepName, this.cwd))
+      )
+    );
+  }
   async executeWorkflow(taskId, userQuery, startIndex = 0, feedback) {
     let previousOutput;
     if (startIndex > 0) {
@@ -954,7 +829,6 @@ var CliPlatform = class extends BasePlatform {
   async callClaude(prompt) {
     return new Promise((resolve, reject) => {
       const proc = spawn2(this.claudeCommand, [
-        "--print",
         "--permission-mode",
         "bypassPermissions"
       ], {
@@ -1024,6 +898,21 @@ var CliPlatform = class extends BasePlatform {
 
 // src/platform/github.ts
 import { spawn as spawn3 } from "child_process";
+async function retryWithBackoff(fn, maxRetries = 3, initialDelayMs = 1e3) {
+  let lastError = null;
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (i === maxRetries - 1) break;
+      const delay = initialDelayMs * Math.pow(2, i);
+      console.log(`Retry ${i + 1}/${maxRetries} after ${delay}ms...`);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw lastError || new Error("Retry failed");
+}
 var PauseForInputError = class extends Error {
   constructor(inputType, data) {
     super(`Paused waiting for ${inputType}`);
@@ -1211,26 +1100,39 @@ var GitHubPlatform = class extends BasePlatform {
     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}`));
+  async runGh(args, timeoutMs = 3e4) {
+    return retryWithBackoff(async () => {
+      return new Promise((resolve, reject) => {
+        const proc = spawn3("gh", args, { stdio: ["pipe", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        let isTimedOut = false;
+        const timeoutId = setTimeout(() => {
+          isTimedOut = true;
+          proc.kill();
+          reject(new Error(`gh command timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        proc.stdout.on("data", (data) => {
+          stdout += data.toString();
+        });
+        proc.stderr.on("data", (data) => {
+          stderr += data.toString();
+        });
+        proc.on("close", (code) => {
+          clearTimeout(timeoutId);
+          if (isTimedOut) return;
+          if (code !== 0) {
+            reject(new Error(`gh command failed: ${stderr}`));
+          } else {
+            resolve(stdout);
+          }
+        });
+        proc.on("error", (err) => {
+          clearTimeout(timeoutId);
+          if (!isTimedOut) {
+            reject(new Error(`Failed to run gh: ${err.message}`));
+          }
+        });
       });
     });
   }
@@ -1264,11 +1166,9 @@ var GitHubPlatform = class extends BasePlatform {
   async callClaude(prompt) {
     return new Promise((resolve, reject) => {
       const proc = spawn3("claude", [
-        "-p",
-        prompt,
         "--permission-mode",
         "bypassPermissions"
-      ], { stdio: ["ignore", "pipe", "pipe"] });
+      ], { stdio: ["pipe", "pipe", "pipe"] });
       let stdout = "";
       let stderr = "";
       proc.stdout.on("data", (data) => {
@@ -1277,6 +1177,8 @@ var GitHubPlatform = class extends BasePlatform {
       proc.stderr.on("data", (data) => {
         stderr += data.toString();
       });
+      proc.stdin.write(prompt);
+      proc.stdin.end();
       proc.on("close", (code) => {
         if (code !== 0) {
           reject(new Error(`Claude CLI failed (code ${code}): stderr=${stderr}, stdout=${stdout}`));
@@ -1402,7 +1304,7 @@ async function startCommand(query, options) {
     process.exit(1);
   }
   const config = loadConfig(cwd);
-  const taskId = generateTaskId();
+  const taskId = generateTaskId(query);
   saveTaskMetadata(taskId, query, cwd);
   let platform;
   if (options.github || options.issue !== void 0 || options.pr !== void 0) {
@@ -1893,7 +1795,7 @@ async function githubCommand(options) {
   }
   if (!taskId) {
     const config2 = loadConfig(cwd);
-    const { listTasks: listTasks2 } = await import("./state-JLYPJWUT.js");
+    const { listTasks: listTasks2 } = await import("./state-54IS3PZH.js");
     const tasks = listTasks2(cwd);
     for (const tid of tasks) {
       const state2 = getWorkflowState(tid, config2, cwd);
@@ -2072,7 +1974,7 @@ _Updated by [Spets](https://github.com/eatnug/spets)_`;
 }
 
 // src/orchestrator/index.ts
-import { readFileSync, writeFileSync as writeFileSync3, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync3, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
 import { join as join4, dirname as dirname2 } from "path";
 import matter from "gray-matter";
 var Orchestrator = class {
@@ -2110,7 +2012,7 @@ var Orchestrator = class {
     if (!existsSync4(statePath)) {
       return null;
     }
-    const data = JSON.parse(readFileSync(statePath, "utf-8"));
+    const data = JSON.parse(readFileSync2(statePath, "utf-8"));
     return data;
   }
   saveState(state) {
@@ -2129,7 +2031,7 @@ var Orchestrator = class {
     if (!existsSync4(specPath)) {
       return [];
     }
-    const content = readFileSync(specPath, "utf-8");
+    const content = readFileSync2(specPath, "utf-8");
     const { data } = matter(content);
     const questions = [];
     if (data.open_questions && Array.isArray(data.open_questions)) {
@@ -2148,11 +2050,6 @@ var Orchestrator = class {
     }
     return questions;
   }
-  generateTaskId(description) {
-    const timestamp = Date.now().toString(36);
-    const random = Math.random().toString(36).substring(2, 6);
-    return `${timestamp}-${random}`;
-  }
   // ===========================================================================
   // Protocol Response Builders
   // ===========================================================================
@@ -2258,7 +2155,7 @@ var Orchestrator = class {
   cmdInit(description) {
     try {
       const steps = this.getSteps();
-      const taskId = this.generateTaskId(description);
+      const taskId = generateTaskId(description);
       const state = {
         taskId,
         description,
@@ -2306,7 +2203,7 @@ var Orchestrator = class {
     }
     const specPath = this.getSpecPath(taskId, state.currentStep);
     if (existsSync4(specPath)) {
-      const content = readFileSync(specPath, "utf-8");
+      const content = readFileSync2(specPath, "utf-8");
       const { content: body, data } = matter(content);
       if (data.open_questions && Array.isArray(data.open_questions)) {
         data.open_questions = data.open_questions.map((q, i) => ({
@@ -2333,7 +2230,7 @@ var Orchestrator = class {
     const steps = this.getSteps();
     const specPath = this.getSpecPath(taskId, state.currentStep);
     if (existsSync4(specPath)) {
-      const content = readFileSync(specPath, "utf-8");
+      const content = readFileSync2(specPath, "utf-8");
       const { content: body, data } = matter(content);
       data.status = "approved";
       data.updated_at = (/* @__PURE__ */ new Date()).toISOString();
@@ -2375,7 +2272,7 @@ var Orchestrator = class {
     }
     const specPath = this.getSpecPath(taskId, state.currentStep);
     if (existsSync4(specPath)) {
-      const content = readFileSync(specPath, "utf-8");
+      const content = readFileSync2(specPath, "utf-8");
       const { content: body, data } = matter(content);
       data.status = "rejected";
       data.updated_at = (/* @__PURE__ */ new Date()).toISOString();

package/dist/{state-JLYPJWUT.js → state-54IS3PZH.js}

@@ -1,6 +1,7 @@
 import {
   createDocument,
   ensureTaskDir,
+  extractPlanSummary,
   generateTaskId,
   getOutputPath,
   getTaskDir,
@@ -12,10 +13,11 @@ import {
   saveDocument,
   saveTaskMetadata,
   updateDocumentStatus
-} from "./chunk-YK5ZZE4P.js";
+} from "./chunk-NOS3N4GT.js";
 export {
   createDocument,
   ensureTaskDir,
+  extractPlanSummary,
   generateTaskId,
   getOutputPath,
   getTaskDir,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spets",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Spec Driven Development Execution Framework",
   "type": "module",
   "main": "dist/index.js",