@dreki-gg/pi-plan-mode 0.6.4 → 0.10.1

package/extensions/plan-mode/types.ts

@@ -0,0 +1,32 @@
+/**
+ * Shared types for plan mode.
+ */
+
+export interface PlanStep {
+  description: string;
+  details: string;
+  status: 'pending' | 'done' | 'skipped' | 'blocked';
+  notes?: string;
+}
+
+export interface PlanData {
+  title: string;
+  context: string;
+  steps: PlanStep[];
+  risks: string;
+}
+
+export type ThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+
+export interface ExecPendingConfig {
+  model: { provider: string; id: string };
+  thinking: string;
+}
+
+export interface PersistedState {
+  planEnabled: boolean;
+  executing: boolean;
+  planDir: string | undefined;
+  plan: PlanData | undefined;
+  executionStartIdx: number | undefined;
+}

package/extensions/plan-mode/ui.ts

@@ -0,0 +1,39 @@
+/**
+ * Plan mode UI — status bar and step widget rendering.
+ */
+
+import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
+import type { PlanModeState } from './state.js';
+
+export function updateUI(state: PlanModeState, ctx: ExtensionContext): void {
+  const { theme } = ctx.ui;
+
+  if (state.executing && state.plan) {
+    const done = state.plan.steps.filter((s) => s.status === 'done').length;
+    const total = state.plan.steps.length;
+    ctx.ui.setStatus('plan-mode', theme.fg('accent', `📋 exec ${done}/${total}`));
+  } else if (state.planEnabled) {
+    ctx.ui.setStatus('plan-mode', theme.fg('warning', '📝 plan'));
+  } else {
+    ctx.ui.setStatus('plan-mode', undefined);
+  }
+
+  if (state.executing && state.plan) {
+    const lines = state.plan.steps.map((step, i) => {
+      const num = `${i + 1}. `;
+      switch (step.status) {
+        case 'done':
+          return theme.fg('success', '✓ ') + theme.fg('muted', theme.strikethrough(num + step.description));
+        case 'skipped':
+          return theme.fg('warning', '⊘ ') + theme.fg('muted', theme.strikethrough(num + step.description));
+        case 'blocked':
+          return theme.fg('error', '✗ ') + theme.fg('error', num + step.description);
+        default:
+          return theme.fg('muted', '☐ ') + (num + step.description);
+      }
+    });
+    ctx.ui.setWidget('plan-todos', lines);
+  } else {
+    ctx.ui.setWidget('plan-todos', undefined);
+  }
+}

package/extensions/plan-mode/utils.ts

@@ -6,12 +6,6 @@
 
 import { isSafeCommand as baseSafeCommand } from '@dreki-gg/pi-command-sandbox';
 
-export interface TodoItem {
-  step: number;
-  text: string;
-  completed: boolean;
-}
-
 /**
  * Check if a command is safe for plan mode.
  *
@@ -20,7 +14,7 @@ export interface TodoItem {
  */
 export function isSafeCommand(command: string): boolean {
   return baseSafeCommand(command, {
-    allowCommand: (cmd) => isMkdirPlans(cmd) || isCurlWithStderrRedirect(cmd),
+    allowCommand: (cmd) => isMkdirPlans(cmd),
   });
 }
 
@@ -29,81 +23,6 @@ function isMkdirPlans(command: string): boolean {
   return /^\s*mkdir\s+(-p\s+)?\.plans(\/|\\|\s|$)/.test(command);
 }
 
-/**
- * Allow curl commands that only redirect stderr to /dev/null.
- * shell-quote parses `2>/dev/null` as a stdout redirect, but it's
- * actually a stderr redirect which is safe for read-only mode.
- */
-function isCurlWithStderrRedirect(command: string): boolean {
-  return (
-    /^\s*curl\b/.test(command) &&
-    /2>\/dev\/null/.test(command) &&
-    !/>(?!\/dev\/null)/.test(command.replace(/2>\/dev\/null/g, ''))
-  );
-}
-
-// ── Plan extraction ─────────────────────────────────────────────────────────
-
-export function cleanStepText(text: string): string {
-  let cleaned = text
-    .replace(/\*{1,2}([^*]+)\*{1,2}/g, '$1')
-    .replace(/`([^`]+)`/g, '$1')
-    .replace(/\s+/g, ' ')
-    .trim();
-
-  if (cleaned.length > 0) {
-    cleaned = cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
-  }
-  if (cleaned.length > 60) {
-    cleaned = `${cleaned.slice(0, 57)}...`;
-  }
-  return cleaned;
-}
-
-export function extractTodoItems(message: string): TodoItem[] {
-  const items: TodoItem[] = [];
-  const headerMatch = message.match(/\*{0,2}Plan:\*{0,2}\s*\n/i);
-  if (!headerMatch) return items;
-
-  const planSection = message.slice(message.indexOf(headerMatch[0]) + headerMatch[0].length);
-  const numberedPattern = /^\s*(\d+)[.)]\s+\*{0,2}([^*\n]+)/gm;
-
-  for (const match of planSection.matchAll(numberedPattern)) {
-    const text = match[2]
-      .trim()
-      .replace(/\*{1,2}$/, '')
-      .trim();
-
-    if (text.length <= 5) continue;
-    if (text.startsWith('`') || text.startsWith('/') || text.startsWith('-')) continue;
-
-    const cleaned = cleanStepText(text);
-    if (cleaned.length <= 3) continue;
-
-    items.push({ step: items.length + 1, text: cleaned, completed: false });
-  }
-
-  return items;
-}
-
-export function extractDoneSteps(message: string): number[] {
-  const steps: number[] = [];
-  for (const match of message.matchAll(/\[DONE:(\d+)\]/gi)) {
-    const step = Number(match[1]);
-    if (Number.isFinite(step)) steps.push(step);
-  }
-  return steps;
-}
-
-export function markCompletedSteps(text: string, items: TodoItem[]): number {
-  const doneSteps = extractDoneSteps(text);
-  for (const step of doneSteps) {
-    const item = items.find((t) => t.step === step);
-    if (item) item.completed = true;
-  }
-  return doneSteps.length;
-}
-
 // ── Plan name utilities ─────────────────────────────────────────────────────
 
 export function toKebabCase(name: string): string {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dreki-gg/pi-plan-mode",
-  "version": "0.6.4",
+  "version": "0.10.1",
   "description": "Two-phase planning workflow for pi — plan with claude-opus-4-6:medium, execute with gpt-5.5:low, with .plans/ file-based handoff",
   "keywords": [
     "pi-package"
@@ -24,23 +24,19 @@
     "package.json"
   ],
   "scripts": {
-    "prepack": "node --experimental-strip-types scripts/prepack.js",
-    "postpack": "rm -rf node_modules/@dreki-gg",
     "typecheck": "tsc --noEmit",
     "lint": "oxlint extensions bin",
     "format": "oxfmt --write extensions bin",
-    "format:check": "oxfmt --check extensions bin"
+    "format:check": "oxfmt --check extensions bin",
+    "test": "bun test extensions/plan-mode/__tests__"
   },
   "pi": {
     "extensions": [
       "./extensions/plan-mode"
     ]
   },
-  "bundledDependencies": [
-    "@dreki-gg/pi-command-sandbox"
-  ],
   "dependencies": {
-    "@dreki-gg/pi-command-sandbox": "0.1.0"
+    "@dreki-gg/pi-command-sandbox": "^0.2.0"
   },
   "devDependencies": {
     "@types/node": "24",

package/node_modules/@dreki-gg/pi-command-sandbox/dist/index.d.mts

@@ -1,104 +0,0 @@
-//#region src/sandbox.d.ts
-/**
- * Core sandbox logic — determines whether a shell command is safe to execute.
- */
-interface SandboxOptions {
-  /**
-   * Extra patterns to allow beyond the built-in SAFE_PATTERNS.
-   * Checked against the reconstructed command string for each segment.
-   */
-  extraSafe?: RegExp[];
-  /**
-   * Extra patterns to block beyond the built-in DESTRUCTIVE_PATTERNS.
-   * Checked against the reconstructed command string for each segment.
-   */
-  extraDestructive?: RegExp[];
-  /**
-   * Custom predicate to allow specific full commands before normal checks.
-   * Return `true` to allow the command, `false` to continue with normal checks.
-   */
-  allowCommand?: (command: string) => boolean;
-  /**
-   * Whether to allow stdout redirects (`>`, `>>`).
-   * Default: false (blocked).
-   */
-  allowRedirects?: boolean;
-  /**
-   * Whether to allow command substitution ($(...) and backticks).
-   * Default: false (blocked).
-   */
-  allowCommandSubstitution?: boolean;
-}
-/**
- * Check if a shell command is safe to execute in a sandboxed mode.
- *
- * The command is parsed into segments using shell-quote, and each segment
- * is checked independently against the destructive and safe pattern lists.
- * A command is safe only if ALL segments pass.
- *
- * For a segment to pass:
- * 1. It must NOT match any destructive pattern
- * 2. It MUST match at least one safe pattern
- * 3. It must NOT contain redirects (unless explicitly allowed)
- *
- * Additionally, command substitution ($() and backticks) is blocked by default.
- */
-declare function isSafeCommand(command: string, options?: SandboxOptions): boolean;
-//#endregion
-//#region src/parser.d.ts
-/**
- * Shell command parser using shell-quote.
- *
- * Splits a full shell command string into individual command segments,
- * properly handling &&, ||, ;, |, pipes, quotes, and subshells.
- */
-interface ParsedSegment {
-  /** The reconstructed command string for this segment. */
-  command: string;
-  /** Whether this segment contains a redirect operator. */
-  hasRedirect: boolean;
-}
-/**
- * Parse a shell command into individual command segments.
- *
- * Uses shell-quote to properly tokenize the input, then splits on
- * command separators (&&, ||, ;, |). Each segment is returned as a
- * reconstructed command string.
- *
- * Subshell grouping operators `(` and `)` are stripped — the inner
- * commands are still validated individually.
- *
- * @example
- * ```ts
- * parseCommandSegments('cd foo && ls -la')
- * // → [{ command: 'cd foo', hasRedirect: false },
- * //    { command: 'ls -la', hasRedirect: false }]
- *
- * parseCommandSegments('echo "hello && world"')
- * // → [{ command: 'echo "hello && world"', hasRedirect: false }]
- *
- * parseCommandSegments('curl -s url 2>/dev/null | head')
- * // → [{ command: 'curl -s url 2>/dev/null', hasRedirect: false },
- * //    { command: 'head', hasRedirect: false }]
- * ```
- */
-declare function parseCommandSegments(input: string): ParsedSegment[];
-/**
- * Check if the parsed tokens contain command substitution patterns.
- *
- * Command substitution ($(...) or `...`) can hide arbitrary commands
- * and should be blocked in sandboxed modes.
- */
-declare function hasCommandSubstitution(input: string): boolean;
-//#endregion
-//#region src/patterns.d.ts
-/**
- * Destructive and safe command patterns for shell sandboxing.
- *
- * DESTRUCTIVE_PATTERNS — if any segment matches, the command is blocked.
- * SAFE_PATTERNS — a segment must match at least one to be allowed.
- */
-declare const DESTRUCTIVE_PATTERNS: RegExp[];
-declare const SAFE_PATTERNS: RegExp[];
-//#endregion
-export { DESTRUCTIVE_PATTERNS, type ParsedSegment, SAFE_PATTERNS, type SandboxOptions, hasCommandSubstitution, isSafeCommand, parseCommandSegments };