supipowers 0.7.7 → 0.7.9

package/bin/ctx-mode-wrapper.mjs

@@ -10,10 +10,9 @@
 // rules since that's what OMP actually loads as system prompt.
 
 import { resolve, join, dirname } from "node:path";
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync, copyFileSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
-import os from "node:os";
 
 const __wrapperDir = dirname(fileURLToPath(import.meta.url));
 
@@ -21,38 +20,10 @@ const __wrapperDir = dirname(fileURLToPath(import.meta.url));
 const projectDir = resolve(process.cwd());
 process.env.CLAUDE_PROJECT_DIR = projectDir;
 
-// Redirect context-mode's FTS5 database to a project-scoped directory.
-// ContentStore uses `join(tmpdir(), "context-mode-<pid>.db")`.
-// By patching os.tmpdir, the DB lives in .omp/context-mode/ instead of /tmp/.
-// We also copy the previous session's DB to the new PID filename so indexed
-// content persists across sessions (context-mode creates per-PID filenames).
-const ctxDbDir = join(projectDir, ".omp", "context-mode");
-if (!existsSync(ctxDbDir)) mkdirSync(ctxDbDir, { recursive: true });
-
-// Find the most recent existing DB and copy it for the new session
-const currentDbName = `context-mode-${process.pid}.db`;
-try {
-  const existing = readdirSync(ctxDbDir)
-    .filter(f => f.match(/^context-mode-\d+\.db$/) && f !== currentDbName);
-  if (existing.length > 0) {
-    // Pick the newest by mtime
-    const newest = existing
-      .map(f => ({ name: f, mtime: statSync(join(ctxDbDir, f)).mtimeMs }))
-      .sort((a, b) => b.mtime - a.mtime)[0];
-    if (newest) {
-      copyFileSync(join(ctxDbDir, newest.name), join(ctxDbDir, currentDbName));
-      // Also copy WAL/SHM if they exist
-      for (const suffix of ["-wal", "-shm"]) {
-        const src = join(ctxDbDir, newest.name + suffix);
-        if (existsSync(src)) {
-          copyFileSync(src, join(ctxDbDir, currentDbName + suffix));
-        }
-      }
-    }
-  }
-} catch { /* best effort */ }
-
-os.tmpdir = () => ctxDbDir;
+// Note: context-mode uses per-PID ephemeral FTS5 databases that are cleaned
+// up on process exit. Within a session, indexed content persists and ctx_search
+// can query it. Across sessions, content must be re-indexed.
+// The SKILL.md routing rules emphasize using ctx_search for follow-ups.
 
 // Resolve start.mjs path from the first CLI argument
 const startMjs = process.argv[2];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supipowers",
-  "version": "0.7.7",
+  "version": "0.7.9",
   "description": "OMP-native workflow extension inspired by supipowers.",
   "type": "module",
   "scripts": {

package/src/commands/run.ts

@@ -28,16 +28,76 @@ import { buildBranchFinishPrompt } from "../git/branch-finish.js";
 import { detectBaseBranch } from "../git/base-branch.js";
 import type { RunManifest, AgentResult } from "../types.js";
 
+interface ParsedRunArgs {
+  profile?: string;
+  plan?: string;
+}
+
+export function parseRunArgs(args: string | undefined): ParsedRunArgs {
+  if (!args) return {};
+  const result: ParsedRunArgs = {};
+  const profileMatch = args.match(/--profile\s+(\S+)/);
+  if (profileMatch && !profileMatch[1].startsWith("--")) {
+    result.profile = profileMatch[1];
+  }
+  const planMatch = args.match(/--plan\s+(\S+)/);
+  if (planMatch && !planMatch[1].startsWith("--")) {
+    result.plan = planMatch[1];
+  }
+  // If no flags were matched, treat the whole string as a plan name (backwards compat)
+  if (!result.profile && !result.plan) {
+    const trimmed = args.trim();
+    if (trimmed && !trimmed.startsWith("--")) result.plan = trimmed;
+  }
+  return result;
+}
+
+export function formatAge(isoDate: string): string {
+  const ms = Math.max(0, Date.now() - new Date(isoDate).getTime());
+  if (Number.isNaN(ms)) return "unknown";
+  const mins = Math.floor(ms / 60_000);
+  if (mins < 60) return `${mins}m`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ${mins % 60}m`;
+  return `${Math.floor(hours / 24)}d ${hours % 24}h`;
+}
+
 export function registerRunCommand(pi: ExtensionAPI): void {
   pi.registerCommand("supi:run", {
     description: "Execute a plan with sub-agent orchestration",
     async handler(args, ctx) {
       const config = loadConfig(ctx.cwd);
-      const profile = resolveProfile(ctx.cwd, config, args?.replace("--profile ", "") || undefined);
+      const parsed = parseRunArgs(args);
+      const profile = resolveProfile(ctx.cwd, config, parsed.profile);
 
       let manifest = findActiveRun(ctx.cwd);
       let branchName: string | null = null;
 
+      // Handle active run: prompt user to resume or start fresh
+      if (manifest) {
+        if (ctx.hasUI) {
+          const age = formatAge(manifest.startedAt);
+          const choice = await ctx.ui.select(
+            `Found active run ${manifest.id} for plan '${manifest.planRef}' (started ${age} ago)`,
+            ["Resume", "Start fresh"],
+          );
+          if (!choice) return;
+
+          if (choice === "Start fresh") {
+            manifest.status = "cancelled";
+            manifest.completedAt = new Date().toISOString();
+            updateRun(ctx.cwd, manifest);
+            manifest = null;
+          } else {
+            notifyInfo(ctx, `Resuming run: ${manifest.id}`);
+          }
+        } else {
+          // No UI — resume automatically
+          notifyInfo(ctx, `Resuming run: ${manifest.id}`);
+        }
+      }
+
+      // Create a new run if no active run or user chose "Start fresh"
       if (!manifest) {
         const plans = listPlans(ctx.cwd);
         if (plans.length === 0) {
@@ -45,7 +105,8 @@ export function registerRunCommand(pi: ExtensionAPI): void {
           return;
         }
 
-        const planName = args?.trim() || plans[0];
+        const planName = parsed.plan || plans[0];
+        notifyInfo(ctx, "Using plan", planName);
         const planContent = readPlanFile(ctx.cwd, planName);
         if (!planContent) {
           notifyError(ctx, "Plan not found", planName);
@@ -53,6 +114,14 @@ export function registerRunCommand(pi: ExtensionAPI): void {
         }
 
         const plan = parsePlan(planContent, planName);
+        if (plan.tasks.length === 0) {
+          notifyError(
+            ctx,
+            "No tasks found in plan",
+            "Task headers must use '### N. Name' or '### Task N: Name' format",
+          );
+          return;
+        }
         const batches = scheduleBatches(plan.tasks, config.orchestration.maxParallelAgents);
 
         manifest = {
@@ -95,8 +164,6 @@ export function registerRunCommand(pi: ExtensionAPI): void {
             notifyInfo(ctx, "Setting up worktree", `Branch: ${branchName}`);
           }
         }
-      } else {
-        notifyInfo(ctx, `Resuming run: ${manifest.id}`);
       }
 
       const planContent = readPlanFile(ctx.cwd, manifest.planRef);

package/src/storage/plans.ts

@@ -74,20 +74,28 @@ function extractContext(content: string): string {
   return contextMatch?.[1]?.trim() ?? "";
 }
 
+/** Strip fenced code blocks to prevent matching task headers inside examples */
+function stripCodeBlocks(content: string): string {
+  return content.replace(/```[\s\S]*?```/g, "");
+}
+
 function parseTasksFromMarkdown(content: string): PlanTask[] {
   const tasks: PlanTask[] = [];
-  const taskRegex = /### (\d+)\. (.+)/g;
+  // Strip code blocks so we don't match headers inside examples
+  const stripped = stripCodeBlocks(content);
+  // Match both "### 1. Name" and "### Task 1: Name" formats, anchored to line start
+  const taskRegex = /^### (?:Task )?(\d+)[.:] (.+)/gm;
   let match: RegExpExecArray | null;
 
-  while ((match = taskRegex.exec(content)) !== null) {
+  while ((match = taskRegex.exec(stripped)) !== null) {
     const id = parseInt(match[1], 10);
     const headerLine = match[2];
     const startIdx = match.index + match[0].length;
-    const nextTaskMatch = /\n### \d+\. /.exec(content.slice(startIdx));
+    const nextTaskMatch = /\n### (?:Task )?\d+[.:] /.exec(stripped.slice(startIdx));
     const endIdx = nextTaskMatch
       ? startIdx + nextTaskMatch.index
-      : content.length;
-    const body = content.slice(startIdx, endIdx);
+      : stripped.length;
+    const body = stripped.slice(startIdx, endIdx);
 
     const name = headerLine.replace(/\[.*?\]/g, "").trim();
     const parallelism = parseParallelism(headerLine);
@@ -111,18 +119,48 @@ function parseParallelism(header: string): TaskParallelism {
 }
 
 function parseFiles(body: string): string[] {
-  const filesMatch = body.match(/\*\*files?\*\*:\s*(.+)/i);
-  if (!filesMatch) return [];
-  return filesMatch[1].split(",").map((s) => s.trim());
+  // Match header only (no greedy \s* that eats newlines)
+  // Supports: **files**: ..., **File**: ..., **Files:** ...
+  const headerMatch = body.match(/\*\*files?\*\*:/i) ?? body.match(/\*\*files?:\*\*/i);
+  if (!headerMatch) return [];
+
+  const afterHeader = body.slice(headerMatch.index! + headerMatch[0].length);
+  const firstLine = afterHeader.split("\n")[0].trim();
+
+  // Single-line format: **files**: src/a.ts, src/b.ts
+  if (firstLine && !firstLine.startsWith("-")) {
+    return firstLine.split(",").map((s) => s.trim());
+  }
+
+  // Multi-line format: **Files:**\n- Modify: `src/a.ts`\n- Create: `src/b.ts`
+  const lines = afterHeader.split("\n");
+  const files: string[] = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("-")) {
+      if (trimmed === "") continue; // skip blank lines between header and list
+      break; // non-list line = end of files section
+    }
+    // Strip "- Modify: `src/types.ts`" → "src/types.ts"
+    const content = trimmed.slice(1).trim(); // remove leading -
+    const afterPrefix = content.replace(/^(?:Modify|Create|Test|Delete|Rename|Move):\s*/i, "");
+    const filePath = afterPrefix.replace(/`/g, "").replace(/\s*\(.*\)\s*$/, "").trim();
+    if (filePath && !filePath.startsWith("(")) {
+      files.push(filePath);
+    }
+  }
+  return files;
 }
 
 function parseCriteria(body: string): string {
-  const match = body.match(/\*\*criteria\*\*:\s*(.+)/i);
+  // Match both **criteria**: ... and **Criteria:** ...
+  const match = body.match(/\*\*criteria\*\*:\s*(.+)/i) ?? body.match(/\*\*criteria:\*\*\s*(.+)/i);
   return match?.[1]?.trim() ?? "";
 }
 
 function parseComplexity(body: string): TaskComplexity {
-  const match = body.match(/\*\*complexity\*\*:\s*(\w+)/i);
+  // Match both **complexity**: ... and **Complexity:** ...
+  const match = body.match(/\*\*complexity\*\*:\s*(\w+)/i) ?? body.match(/\*\*complexity:\*\*\s*(\w+)/i);
   const val = match?.[1]?.toLowerCase();
   if (val === "small" || val === "medium" || val === "large") return val;
   return "medium";

package/src/types.ts

@@ -53,7 +53,7 @@ export interface RunBatch {
 }
 
 /** Overall run status */
-export type RunStatus = "running" | "completed" | "paused" | "failed";
+export type RunStatus = "running" | "completed" | "paused" | "failed" | "cancelled";
 
 /** Run manifest stored on disk */
 export interface RunManifest {