pi-harness-runtime 0.10.5 → 0.10.7

package/packages/todo-bd-sync/src/task-analyzer.ts

@@ -0,0 +1,266 @@
+/**
+ * Smart Auto-Todo Task Analyzer
+ *
+ * Decides when to automatically create bd issues based on:
+ * 1. Task complexity signals
+ * 2. Session state (pending task count)
+ *
+ * Philosophy:
+ * - Simple tasks (grep, quick edit) -> NO todo (avoid noise)
+ * - Complex tasks OR multiple pending tasks -> AUTO-CREATE todo
+ */
+
+import { getOpenBdIssues } from "./sync.js";
+
+// ─── Complexity Signals ─────────────────────────────────────────────────────────
+
+interface TaskSignals {
+	/** Estimated number of steps required */
+	stepCount: number;
+	/** Number of files likely involved */
+	fileCount: number;
+	/** Requires research (web search, docs lookup) */
+	needsResearch: boolean;
+	/** Creates new files */
+	createsFiles: boolean;
+	/** User explicitly says task is complex */
+	explicitlyComplex: boolean;
+	/** Likely to have subtasks discovered during work */
+	likelySubtasks: boolean;
+}
+
+const COMPLEX_KEYWORDS = [
+	"complicated", "complex", "tricky", "difficult", "refactor",
+	"architecture", "design", "implement from scratch", "rewrite",
+	"investigate", "debug", "fix the bug", "performance",
+];
+
+const RESEARCH_KEYWORDS = [
+	"search", "look up", "find", "research", "check", "verify",
+	"how to", "best practice", "compare", "evaluate", "review",
+];
+
+const SUBTASK_KEYWORDS = [
+	"also", "plus", "and also", "while you're at it", "on top of that",
+	"additionally", "another thing", "don't forget", "should also",
+];
+
+/**
+ * Analyze user request text for complexity signals
+ */
+export function analyzeTaskSignals(userMessage: string): TaskSignals {
+	const lower = userMessage.toLowerCase();
+
+	// Count implied steps from action verbs
+	const actionVerbs = [
+		"create", "build", "implement", "design", "setup", "configure",
+		"migrate", "convert", "refactor", "optimize", "fix", "update",
+		"add", "remove", "delete", "modify", "change", "replace",
+	];
+	const stepCount = Math.max(1, actionVerbs.filter(v => lower.includes(v)).length);
+
+	// Estimate file count from file paths and extensions
+	const filePatterns = /[\w-]+\.(ts|js|py|json|md|yaml|yml|tsx|jsx|html|css|sql)/g;
+	const fileMatches = userMessage.match(filePatterns) || [];
+	const explicitFiles = fileMatches.length;
+
+	// Check for directory patterns
+	const dirPatterns = /(?:src|lib|packages|apps|components|hooks|utils|api)\/[\w/-]+/g;
+	const dirMatches = userMessage.match(dirPatterns) || [];
+
+	// Count "and", "also", "+" for multi-task indicators
+	const multiTaskIndicator = (lower.match(/and also|also|\+/g) || []).length;
+	const estimatedFiles = Math.max(1, explicitFiles + dirMatches.length + multiTaskIndicator);
+
+	return {
+		stepCount,
+		fileCount: estimatedFiles,
+		needsResearch: RESEARCH_KEYWORDS.some(k => lower.includes(k)),
+		createsFiles: lower.includes("create") || lower.includes("add") || lower.includes("new"),
+		explicitlyComplex: COMPLEX_KEYWORDS.some(k => lower.includes(k)),
+		likelySubtasks: SUBTASK_KEYWORDS.some(k => lower.includes(k)) || multiTaskIndicator >= 2,
+	};
+}
+
+// ─── Decision Logic ───────────────────────────────────────────────────────────
+
+export interface AutoTodoDecision {
+	shouldCreate: boolean;
+	reason: string;
+	confidence: "high" | "medium" | "low";
+	skipReason?: string;
+}
+
+/**
+ * Decide whether to auto-create a todo for the given task
+ */
+export function decideAutoTodo(
+	userMessage: string,
+	options: {
+		forceMode?: boolean;
+		skipMode?: boolean;
+	} = {},
+): AutoTodoDecision {
+	const signals = analyzeTaskSignals(userMessage);
+	const pendingTasks = getOpenBdIssues().filter(i => i.status !== "closed");
+	const pendingCount = pendingTasks.length;
+
+	// ── Skip Conditions ────────────────────────────────────────────────────
+	// Never create todos for these
+
+	const simplePatterns = [
+		/^simply\s/i,
+		/^just\s/i,
+		/^quick\s/i,
+		/^can you\s+(grep|find|cat|ls|echo)/i,
+		/^(grep|find|cat|ls)\s+[\w.-]+/i,
+		/^what('s| is) the\s+\w+\s+\?$/i,
+		/^how do i\s+\w+\s*\?$/i,
+	];
+
+	if (simplePatterns.some(p => p.test(userMessage.trim()))) {
+		return {
+			shouldCreate: false,
+			reason: "Simple request (lookup/one-liner)",
+			confidence: "high",
+			skipReason: "Task is too simple to warrant tracking",
+		};
+	}
+
+	// Check for single file, single action with no complexity
+	if (
+		signals.stepCount === 1 &&
+		signals.fileCount <= 1 &&
+		!signals.needsResearch &&
+		!signals.createsFiles &&
+		!signals.explicitlyComplex &&
+		pendingCount === 0
+	) {
+		return {
+			shouldCreate: false,
+			reason: "Single action, single file, no research needed",
+			confidence: "high",
+			skipReason: "Task is straightforward",
+		};
+	}
+
+	// ── Force Modes ──────────────────────────────────────────────────────
+	if (options.forceMode) {
+		return {
+			shouldCreate: true,
+			reason: "Force mode enabled",
+			confidence: "high",
+		};
+	}
+
+	if (options.skipMode) {
+		return {
+			shouldCreate: false,
+			reason: "Skip mode enabled",
+			confidence: "high",
+			skipReason: "User requested skip",
+		};
+	}
+
+	// ── Auto-Create Conditions ──────────────────────────────────────────
+	const reasons: string[] = [];
+
+	// HIGH CONFIDENCE: Task explicitly complex
+	if (signals.explicitlyComplex) {
+		reasons.push("explicitly complex");
+	}
+
+	// HIGH CONFIDENCE: Multiple steps
+	if (signals.stepCount >= 3) {
+		reasons.push(`${signals.stepCount} steps implied`);
+	}
+
+	// HIGH CONFIDENCE: Multiple files
+	if (signals.fileCount >= 3) {
+		reasons.push(`${signals.fileCount} files involved`);
+	}
+
+	// MEDIUM CONFIDENCE: Research needed
+	if (signals.needsResearch && signals.stepCount >= 2) {
+		reasons.push("research + action");
+	}
+
+	// MEDIUM CONFIDENCE: Creates files + action
+	if (signals.createsFiles && signals.fileCount >= 2) {
+		reasons.push("creates multiple files");
+	}
+
+	// MEDIUM CONFIDENCE: Likely subtasks
+	if (signals.likelySubtasks) {
+		reasons.push("likely has subtasks");
+	}
+
+	// HIGH CONFIDENCE: Already 2+ pending tasks (session overload)
+	if (pendingCount >= 2) {
+		reasons.push(`${pendingCount} pending tasks in session`);
+	}
+
+	// HIGH CONFIDENCE: 3+ pending tasks
+	if (pendingCount >= 3) {
+		reasons.push("session overwhelmed (3+ pending)");
+	}
+
+	if (reasons.length === 0) {
+		return {
+			shouldCreate: false,
+			reason: "No strong complexity signals",
+			confidence: "low",
+			skipReason: "Task doesn't meet auto-create threshold",
+		};
+	}
+
+	// Need at least 2 signals OR high-pending count
+	const highConfidenceReasons = ["explicitly complex", "pending tasks in session", "session overwhelmed"];
+	const hasHighConfidence = reasons.some(r => highConfidenceReasons.some(h => r.includes(h)));
+	const shouldCreate = reasons.length >= 2 || hasHighConfidence || pendingCount >= 2;
+
+	return {
+		shouldCreate,
+		reason: reasons.join(", "),
+		confidence: hasHighConfidence ? "high" : reasons.length >= 2 ? "medium" : "low",
+	};
+}
+
+// ─── Quick Score ─────────────────────────────────────────────────────────────
+
+/**
+ * Quick numeric score (0-100) for task complexity
+ * Higher = more likely to need a todo
+ */
+export function getTaskComplexityScore(userMessage: string): number {
+	const signals = analyzeTaskSignals(userMessage);
+	const pendingTasks = getOpenBdIssues().filter(i => i.status !== "closed");
+
+	let score = 0;
+
+	// Step count (0-25)
+	score += Math.min(25, signals.stepCount * 8);
+
+	// File count (0-20)
+	score += Math.min(20, signals.fileCount * 5);
+
+	// Research needed (0-15)
+	if (signals.needsResearch) score += 15;
+
+	// Creates files (0-10)
+	if (signals.createsFiles) score += 10;
+
+	// Explicitly complex (0-20)
+	if (signals.explicitlyComplex) score += 20;
+
+	// Likely subtasks (0-10)
+	if (signals.likelySubtasks) score += 10;
+
+	// Pending task overload (0-25)
+	const pendingCount = pendingTasks.length;
+	if (pendingCount >= 3) score += 25;
+	else if (pendingCount >= 2) score += 15;
+	else if (pendingCount >= 1) score += 5;
+
+	return Math.min(100, score);
+}

package/packages/token-estimation/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/token-estimation",
-  "version": "0.10.5",
+  "version": "0.10.7",
   "description": "pi-harness-runtime — token-estimation",
   "type": "module",
   "main": "./dist/index.js",

package/packages/token-optimizer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/token-optimizer",
-  "version": "0.10.5",
+  "version": "0.10.7",
   "description": "Token Budget Optimizer — maximize prompt value within token limits (RFC-0011)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/tui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/tui",
-  "version": "0.10.5",
+  "version": "0.10.7",
   "description": "pi-harness-runtime — tui",
   "type": "module",
   "main": "./dist/index.js",

package/packages/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/types",
-  "version": "0.10.5",
+  "version": "0.10.7",
   "description": "Shared TypeScript types for pi-harness-runtime packages",
   "type": "module",
   "main": "./src/index.js",

package/packages/workflow-events/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/workflow-events",
-  "version": "0.10.5",
+  "version": "0.10.7",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/workspace-scanner/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/workspace-scanner",
-  "version": "0.10.5",
+  "version": "0.10.7",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/worktree/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/worktree",
-  "version": "0.10.5",
+  "version": "0.10.7",
   "description": "pi-harness-runtime — worktree",
   "type": "module",
   "main": "./dist/index.js",

package/packages/write-review/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@moocoding/write-review",
+  "version": "0.10.7",
+  "description": "Two-agent write-review loop with blackboard coordination",
+  "type": "module",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts"
+    }
+  },
+  "keywords": [
+    "pi-extension",
+    "write-review",
+    "blackboard",
+    "multi-agent"
+  ],
+  "author": "MooCoding",
+  "license": "MIT"
+}

package/packages/write-review/src/blackboard.ts

@@ -0,0 +1,245 @@
+/**
+ * Write-Review Blackboard
+ *
+ * File-based coordination between writer and reviewer agents.
+ * Location: {project}/.write-review/status.json
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import type { WriteReviewStatus, ReviewPhase, Verdict } from "./types.js";
+
+const DEFAULT_DIR = ".write-review";
+const STATUS_FILE = "status.json";
+
+export class WriteReviewBlackboard {
+  private readonly projectPath: string;
+  private readonly dir: string;
+  private status: WriteReviewStatus | null = null;
+
+  constructor(projectPath: string, dir: string = DEFAULT_DIR) {
+    this.projectPath = projectPath;
+    this.dir = join(projectPath, dir);
+  }
+
+  /**
+   * Initialize a new write-review session
+   */
+  init(): void {
+    mkdirSync(this.dir, { recursive: true });
+    this.status = {
+      projectPath: this.projectPath,
+      phase: "idle",
+      writerDone: false,
+      iteration: 0,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+    this.save();
+  }
+
+  /**
+   * Load status from disk
+   */
+  load(): WriteReviewStatus | null {
+    const path = join(this.dir, STATUS_FILE);
+    if (!existsSync(path)) {
+      return null;
+    }
+    try {
+      this.status = JSON.parse(readFileSync(path, "utf-8"));
+      return this.status;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Save status to disk
+   */
+  save(): void {
+    if (!this.status) return;
+    this.status.updatedAt = new Date().toISOString();
+    mkdirSync(this.dir, { recursive: true });
+    const path = join(this.dir, STATUS_FILE);
+    writeFileSync(path, JSON.stringify(this.status, null, 2));
+  }
+
+  /**
+   * Get current status
+   */
+  getStatus(): WriteReviewStatus | null {
+    return this.status;
+  }
+
+  /**
+   * Start a new write session
+   */
+  startWriting(): void {
+    if (!this.status) this.init();
+    this.status!.phase = "writing";
+    this.status!.writerDone = false;
+    this.status!.iteration++;
+    this.save();
+  }
+
+  /**
+   * Mark writer as done
+   */
+  writerDone(message?: string): void {
+    if (!this.status) return;
+    this.status.writerDone = true;
+    this.status.writerMessage = message;
+    this.status.phase = "pending_review";
+    this.save();
+  }
+
+  /**
+   * Start reviewing
+   */
+  startReview(): void {
+    if (!this.status) return;
+    this.status.phase = "reviewing";
+    this.status.reviewerStarted = new Date().toISOString();
+    this.save();
+  }
+
+  /**
+   * Record verdict
+   */
+  setVerdict(verdict: Verdict, message?: string): void {
+    if (!this.status) return;
+    this.status.verdict = verdict;
+    this.status.verdictMessage = message;
+
+    switch (verdict) {
+      case "approved":
+        this.status.phase = "approved";
+        this.status.approvedAt = new Date().toISOString();
+        break;
+      case "blocked":
+        this.status.phase = "blocked";
+        this.status.blockedAt = new Date().toISOString();
+        break;
+      case "changes_requested":
+        this.status.phase = "changes_requested";
+        break;
+    }
+    this.save();
+  }
+
+  /**
+   * Record code files written
+   */
+  setCodeFiles(files: string[]): void {
+    if (!this.status) return;
+    this.status.codeFiles = files;
+    this.save();
+  }
+
+  /**
+   * Record requested changes
+   */
+  setChangesRequested(changes: string[]): void {
+    if (!this.status) return;
+    this.status.changesRequested = changes;
+    this.save();
+  }
+
+  /**
+   * Get current phase
+   */
+  getPhase(): ReviewPhase {
+    return this.status?.phase ?? "idle";
+  }
+
+  /**
+   * Get iteration number
+   */
+  getIteration(): number {
+    return this.status?.iteration ?? 0;
+  }
+
+  /**
+   * Check if build is allowed
+   */
+  canBuild(): boolean {
+    return this.status?.phase === "approved";
+  }
+
+  /**
+   * Get blackboard directory path
+   */
+  getPath(): string {
+    return this.dir;
+  }
+
+  /**
+   * Reset to idle
+   */
+  reset(): void {
+    if (!this.status) return;
+    this.status.phase = "idle";
+    this.status.writerDone = false;
+    this.status.verdict = undefined;
+    this.status.verdictMessage = undefined;
+    this.status.reviewerStarted = undefined;
+    this.status.approvedAt = undefined;
+    this.status.blockedAt = undefined;
+    this.status.codeFiles = undefined;
+    this.status.changesRequested = undefined;
+    this.save();
+  }
+
+  /**
+   * Check if a review session exists for this project
+   */
+  exists(): boolean {
+    const path = join(this.dir, STATUS_FILE);
+    return existsSync(path);
+  }
+
+  /**
+   * Export status as markdown for display
+   */
+  toMarkdown(): string {
+    if (!this.status) return "No active write-review session.";
+
+    const { phase, iteration, verdict, verdictMessage, codeFiles } = this.status;
+    const lines = [
+      `## Write-Review Status`,
+      ``,
+      `| Field | Value |`,
+      `|-------|-------|`,
+      `| Phase | ${phase} |`,
+      `| Iteration | ${iteration} |`,
+      `| Verdict | ${verdict ?? "pending"} |`,
+    ];
+
+    if (verdictMessage) {
+      lines.push(`| Message | ${verdictMessage} |`);
+    }
+
+    if (codeFiles && codeFiles.length > 0) {
+      lines.push(``, `### Code Files`);
+      for (const file of codeFiles) {
+        lines.push(`- ${file}`);
+      }
+    }
+
+    return lines.join("\n");
+  }
+}
+
+/**
+ * Create or get blackboard for project
+ */
+export function createBlackboard(projectPath: string, dir?: string): WriteReviewBlackboard {
+  const bb = new WriteReviewBlackboard(projectPath, dir);
+  if (!bb.exists()) {
+    bb.init();
+  } else {
+    bb.load();
+  }
+  return bb;
+}