@pi-unipi/workflow 2.6.1 → 2.9.0

package/commands.ts

@@ -8,6 +8,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { readFileSync, readdirSync, existsSync, statSync } from "fs";
 import { join, basename } from "path";
+import { execFileSync } from "node:child_process";
 import { UNIPI_PREFIX, WORKFLOW_COMMANDS, type UnipiWorkflowEvent } from "@pi-unipi/core";
 
 type CompletionItem = { value: string; label: string; description: string };
@@ -36,111 +37,56 @@ interface WorkflowCommand {
 /**
  * Suggest spec files from .unipi/docs/specs/ for plan command.
  */
-function suggestSpecFiles(prefix: string): CompletionItem[] {
-  const specsDir = join(process.cwd(), ".unipi", "docs", "specs");
-  if (!existsSync(specsDir)) return [];
+/** Suggest .md files from a docs subdirectory, sorted by mtime. */
+function suggestFilesFrom(
+  subdir: string,
+  valuePrefix: string,
+  descLabel: string,
+  prefix: string,
+): CompletionItem[] {
+  const dir = join(process.cwd(), ".unipi", "docs", subdir);
+  if (!existsSync(dir)) return [];
 
   try {
     const search = prefix?.trim().split(/\s+/).pop() ?? "";
-    const files = readdirSync(specsDir)
+    const files = readdirSync(dir)
       .filter((f) => f.endsWith(".md"))
-      .map((f) => ({ name: f, time: statSync(join(specsDir, f)).mtimeMs }))
+      .map((f) => ({ name: f, time: statSync(join(dir, f)).mtimeMs }))
       .sort((a, b) => b.time - a.time);
     return files
       .filter((f) => !search || f.name.includes(search))
       .map((f) => ({
-        value: `specs:${f.name}`,
+        value: `${valuePrefix}:${f.name}`,
         label: basename(f.name, ".md"),
-        description: `Spec: ${f.name}`,
+        description: `${descLabel}: ${f.name}`,
       }));
   } catch {
     return [];
   }
 }
 
-/**
- * Suggest plan files from .unipi/docs/plans/ for work and review-work commands.
- */
-function suggestPlanFiles(prefix: string): CompletionItem[] {
-  const plansDir = join(process.cwd(), ".unipi", "docs", "plans");
-  if (!existsSync(plansDir)) return [];
+function suggestSpecFiles(prefix: string): CompletionItem[] {
+  return suggestFilesFrom("specs", "specs", "Spec", prefix);
+}
 
-  try {
-    const search = prefix?.trim().split(/\s+/).pop() ?? "";
-    const files = readdirSync(plansDir)
-      .filter((f) => f.endsWith(".md"))
-      .map((f) => ({ name: f, time: statSync(join(plansDir, f)).mtimeMs }))
-      .sort((a, b) => b.time - a.time);
-    return files
-      .filter((f) => !search || f.name.includes(search))
-      .map((f) => ({
-        value: `plan:${f.name}`,
-        label: basename(f.name, ".md"),
-        description: `Plan: ${f.name}`,
-      }));
-  } catch {
-    return [];
-  }
+function suggestPlanFiles(prefix: string): CompletionItem[] {
+  return suggestFilesFrom("plans", "plan", "Plan", prefix);
 }
 
-/**
- * Suggest debug files from .unipi/docs/debug/ for fix command.
- */
 function suggestDebugFiles(prefix: string): CompletionItem[] {
-  const debugDir = join(process.cwd(), ".unipi", "docs", "debug");
-  if (!existsSync(debugDir)) return [];
-
-  try {
-    const search = prefix?.trim().split(/\s+/).pop() ?? "";
-    const files = readdirSync(debugDir)
-      .filter((f) => f.endsWith(".md"))
-      .map((f) => ({ name: f, time: statSync(join(debugDir, f)).mtimeMs }))
-      .sort((a, b) => b.time - a.time);
-    return files
-      .filter((f) => !search || f.name.includes(search))
-      .map((f) => ({
-        value: `debug:${f.name}`,
-        label: basename(f.name, ".md"),
-        description: `Debug: ${f.name}`,
-      }));
-  } catch {
-    return [];
-  }
+  return suggestFilesFrom("debug", "debug", "Debug", prefix);
 }
 
-/**
- * Suggest chore files from .unipi/docs/chore/ for chore-execute command.
- */
 function suggestChoreFiles(prefix: string): CompletionItem[] {
-  const choreDir = join(process.cwd(), ".unipi", "docs", "chore");
-  if (!existsSync(choreDir)) return [];
-
-  try {
-    const search = prefix?.trim().split(/\s+/).pop() ?? "";
-    const files = readdirSync(choreDir)
-      .filter((f) => f.endsWith(".md"))
-      .map((f) => ({ name: f, time: statSync(join(choreDir, f)).mtimeMs }))
-      .sort((a, b) => b.time - a.time);
-    return files
-      .filter((f) => !search || f.name.includes(search))
-      .map((f) => ({
-        value: `chore:${f.name}`,
-        label: basename(f.name, ".md"),
-        description: `Chore: ${f.name}`,
-      }));
-  } catch {
-    return [];
-  }
+  return suggestFilesFrom("chore", "chore", "Chore", prefix);
 }
 
-/** Cached per-cwd worktree suggestions. Worktree autocomplete can be invoked on every
- * keystroke, so the recursive scan is intentionally paid only once per session/cwd.
- */
+/** Cached per-cwd worktree suggestions. */
 let worktreeSuggestionsCache: { cwd: string; items: CompletionItem[] } | null = null;
 
 /**
  * Suggest existing worktree names for merge/list commands.
- * Recursively scans for actual git worktrees (directories containing .git files).
+ * Uses `git worktree list --porcelain` for a fast, native scan.
  */
 function suggestWorktrees(): CompletionItem[] {
   const cwd = process.cwd();
@@ -148,49 +94,26 @@ function suggestWorktrees(): CompletionItem[] {
     return worktreeSuggestionsCache.items;
   }
 
-  const worktreesDir = join(cwd, ".unipi", "worktrees");
-  if (!existsSync(worktreesDir)) {
-    worktreeSuggestionsCache = { cwd, items: [] };
-    return worktreeSuggestionsCache.items;
-  }
-
   try {
+    const output = execFileSync("git", ["worktree", "list", "--porcelain"], {
+      encoding: "utf-8",
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
     const results: CompletionItem[] = [];
-
-    /**
-     * Recursively find worktree directories (those containing a .git file).
-     * A worktree's .git file contains: gitdir: /path/to/.git/worktrees/<branch>
-     */
-    function findWorktrees(dir: string, relativePath: string): void {
-      const entries = readdirSync(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = join(dir, entry.name);
-        const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-
-        if (entry.name === ".git" && entry.isFile()) {
-          // This is a worktree — extract branch name from gitdir path
-          try {
-            const gitContent = readFileSync(fullPath, "utf-8").trim();
-            const match = gitContent.match(/gitdir:\s+.+?\/([^/]+)$/);
-            const branchName = match?.[1] ?? entry.name;
-            results.push({
-              value: branchName,
-              label: branchName,
-              description: `Worktree: ${relPath}`,
-            });
-          } catch {
-            // Can't read .git file — skip
-          }
-        } else if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== ".git") {
-          // Recurse into subdirectories (but not into nested .git or node_modules)
-          findWorktrees(fullPath, relPath);
-        }
+    for (const line of output.split("\n")) {
+      if (line.startsWith("worktree ")) {
+        const path = line.slice("worktree ".length);
+        const branch = basename(path);
+        results.push({
+          value: branch,
+          label: branch,
+          description: `Worktree: ${path}`,
+        });
       }
     }
-
-    findWorktrees(worktreesDir, "");
     worktreeSuggestionsCache = { cwd, items: results };
-    return worktreeSuggestionsCache.items;
+    return results;
   } catch {
     worktreeSuggestionsCache = { cwd, items: [] };
     return worktreeSuggestionsCache.items;
@@ -482,10 +405,3 @@ export function registerWorkflowCommands(
     },
   });
 }
-
-/**
- * Get list of all registered workflow command names.
- */
-export function getWorkflowCommandNames(): string[] {
-  return COMMANDS.map((c) => `${UNIPI_PREFIX}${c.name}`);
-}

package/index.ts

@@ -23,6 +23,7 @@ import {
   getBlockedToolsForLevel,
   getSandboxLevel,
   isToolAllowed,
+  isActiveSnapshot,
   type SandboxLevel,
 } from "@pi-unipi/core";
 import { registerWorkflowCommands } from "./commands.js";
@@ -130,11 +131,6 @@ function latestHistoricalSandboxSnapshot(
   return undefined;
 }
 
-function isActiveSnapshot(snapshot: EffectiveSandboxSnapshot): boolean {
-  if (typeof snapshot.details?.active === "boolean") return snapshot.details.active;
-  return typeof snapshot.content === "string" && snapshot.content.includes("Status: active");
-}
-
 export default function (pi: ExtensionAPI) {
   const workflowLifecycle = new WorkflowLifecycle();
   let ralphDetected = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/workflow",
-  "version": "2.6.1",
+  "version": "2.9.0",
   "description": "Structured development workflow commands for Pi coding agent",
   "type": "module",
   "main": "index.ts",
@@ -30,17 +30,21 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.6.1"
+    "@pi-unipi/core": "2.9.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "^0.80.0",
-    "@earendil-works/pi-coding-agent": "^0.80.0",
-    "@earendil-works/pi-tui": "^0.80.0",
+    "@earendil-works/pi-ai": "^0.84.0",
+    "@earendil-works/pi-coding-agent": "^0.84.0",
+    "@earendil-works/pi-tui": "^0.84.0",
     "typebox": "^1.1.38"
   },
   "pi": {
-    "extensions": [],
-    "skills": [],
+    "extensions": [
+      "./index.ts"
+    ],
+    "skills": [
+      "./skills"
+    ],
     "prompts": [],
     "themes": []
   }