@mjasnikovs/pi-task 0.2.1 → 0.2.3

package/README.md

@@ -61,6 +61,9 @@ pi install npm:@mjasnikovs/pi-task
 | `/task-list` | Open the task list in an editor dialog. |
 | `/task-resume [id]` | Resume the most recent (or named) unfinished task. |
 | `/task-cancel` | Cancel the running task (soft-terminal — still resumable). |
+| `/task-auto <feature>` | Plan a feature into a task list and run each title through `/task` in order (resumable). |
+| `/task-auto-resume` | Resume the active `/task-auto` run at the next unfinished task. |
+| `/task-auto-cancel` | Stop the `/task-auto` loop after the current task (still resumable). |
 
 ## The pipeline
 
@@ -74,6 +77,32 @@ pi install npm:@mjasnikovs/pi-task
 
 The finished spec is delivered to your main `pi` conversation via `sendUserMessage`, so you keep working in the same chat — no context handoff, no copy-paste.
 
+## Orchestrating multiple tasks — `/task-auto`
+
+A real feature is usually several tasks, not one. `/task-auto` is a thin planner on top of the single-task pipeline:
+
+```
+/task-auto add multi-tenant billing
+        │
+        ▼
+  ┌──────────┐   ┌──────────┐   ┌─────────────┐
+  │ clarify  │──▶│ decompose│──▶│ TASK_AUTO_…  │   resumable list of task titles
+  │ gray     │   │ → titles │   │ .md (titles) │
+  │ areas    │   └──────────┘   └──────┬───────┘
+  └──────────┘                         │
+                          ┌────────────▼─────────────┐
+                          │  for each unchecked title │
+                          │   → full /task pipeline    │  (spec + implement)
+                          │   → wait until it finishes │
+                          │   → check the box, next    │
+                          └────────────────────────────┘
+```
+
+- **It only produces titles.** All the depth — refine, research, grill, compose, critique — is `/task`'s job, run fresh per title. `/task-auto` never researches or specs anything itself.
+- **Clarify first.** It asks the few clarifying questions whose answers change how the feature splits, then decomposes the answers into an ordered list of task titles written to `.pi-tasks/TASK_AUTO_NNNN.md`.
+- **Sequential, blocking.** Each title runs through `/task` to a spec, the spec is implemented, and the loop waits for that to finish before starting the next title. No overlap.
+- **Crash- and cancel-safe.** Progress is the markdown checkboxes in the AUTO file. `/task-auto-resume` (no id) automatically picks up the active run at the first unchecked title. If a title's `/task` run fails, the loop stops and leaves the run resumable.
+
 ## Bundled tools
 
 `pi-task` also registers four MCP-style worker tools (formerly `@mjasnikovs/pi-worker`). All are parallel-execution-capable, so the parent session can issue several calls in one turn.

package/dist/index.js

@@ -1,6 +1,8 @@
 import { registerTask } from './task/orchestrator.js';
+import { registerTaskAuto } from './task/auto-orchestrator.js';
 import { registerWorkers } from './workers/index.js';
 export default function (pi) {
     registerTask(pi);
+    registerTaskAuto(pi);
     registerWorkers(pi);
 }

package/dist/shared/child-process.js

@@ -27,6 +27,14 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
             stdio: ['ignore', 'pipe', 'pipe']
         });
         let firstByteFired = false;
+        // json-events lines can split across data chunks; this holds the trailing
+        // partial line between chunks so events spanning a boundary still parse.
+        // In json-events mode we deliberately do NOT accumulate the full raw
+        // stream: a long-running child emits hundreds of MB of events and
+        // `stdout += chunk` would overflow V8's max string length (≈512MB),
+        // crashing the process. We only need the parsed text, so we drop the raw
+        // bytes once drained.
+        let lineBuffer = '';
         proc.stdout?.on('data', (d) => {
             if (!firstByteFired) {
                 firstByteFired = true;
@@ -35,15 +43,22 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
             if (discardStdout)
                 return;
             const chunk = d.toString();
-            stdout += chunk;
             if (isJsonEvents) {
-                drainJsonEvents(chunk, opts);
+                lineBuffer = drainJsonEvents(lineBuffer + chunk, opts);
+            }
+            else {
+                stdout += chunk;
             }
         });
         proc.stderr?.on('data', (d) => {
             stderr += d.toString();
         });
         proc.on('close', (code) => {
+            // Flush a final event that wasn't newline-terminated.
+            if (isJsonEvents && lineBuffer.trim().length > 0) {
+                drainJsonEvents(lineBuffer + '\n', opts);
+                lineBuffer = '';
+            }
             const text = isJsonEvents ? (finalText || textDeltaAccum).trim() : undefined;
             resolve({ stdout, stderr, exitCode: code ?? 0, aborted, text });
         });
@@ -65,8 +80,13 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
                 signal.addEventListener('abort', kill, { once: true });
         }
         // ─── JSON event-stream processing ──────────────────────────────────
-        function drainJsonEvents(chunk, jsonOpts) {
-            let buf = chunk;
+        /**
+         * Parse every complete (newline-terminated) JSON line in `buf` and
+         * return the trailing partial line, which the caller carries into the
+         * next chunk. This avoids both losing events that span a chunk boundary
+         * and buffering the entire stream.
+         */
+        function drainJsonEvents(buf, jsonOpts) {
             let nl;
             while ((nl = buf.indexOf('\n')) !== -1) {
                 const line = buf.slice(0, nl).trim();
@@ -83,6 +103,7 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
                     // Non-JSON line (startup banner, etc.) — ignore.
                 }
             }
+            return buf;
         }
         function handleEvent(evt, jsonOpts) {
             const t = typeof evt.type === 'string' ? evt.type : '';

package/dist/task/auto-commit.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Per-task git commit for /task-auto.
+ *
+ * After each decomposed task passes, runAutoLoop snapshots the working tree into
+ * a single commit so the run produces one commit per task. This is best-effort:
+ * outside a git repo, with nothing staged, or on any git error we report the
+ * reason and let the loop continue (the task already succeeded).
+ */
+import { type SpawnFn } from '../shared/child-process.js';
+export interface CommitResult {
+    committed: boolean;
+    /** Short, human-readable reason when committed === false. */
+    reason?: string;
+}
+/**
+ * Stage everything (`git add -A`) and commit it with `message`. Honors
+ * .gitignore via git itself. Never throws — failures surface as
+ * `{committed: false, reason}` so the caller can warn and keep going.
+ */
+export declare function gitCommitAll(cwd: string, message: string, signal?: AbortSignal, spawnFn?: SpawnFn): Promise<CommitResult>;

package/dist/task/auto-commit.js

@@ -0,0 +1,56 @@
+/**
+ * Per-task git commit for /task-auto.
+ *
+ * After each decomposed task passes, runAutoLoop snapshots the working tree into
+ * a single commit so the run produces one commit per task. This is best-effort:
+ * outside a git repo, with nothing staged, or on any git error we report the
+ * reason and let the loop continue (the task already succeeded).
+ */
+import { runChildDefault } from '../shared/child-process.js';
+function firstLine(s) {
+    const line = s.split('\n').find(l => l.trim().length > 0);
+    return (line ?? s).trim();
+}
+async function git(cwd, args, signal, spawnFn) {
+    const r = await runChildDefault({ command: 'git', args }, cwd, signal, { mode: 'text' }, spawnFn);
+    return { stdout: r.stdout, stderr: r.stderr, exitCode: r.exitCode, aborted: r.aborted };
+}
+/**
+ * Stage everything (`git add -A`) and commit it with `message`. Honors
+ * .gitignore via git itself. Never throws — failures surface as
+ * `{committed: false, reason}` so the caller can warn and keep going.
+ */
+export async function gitCommitAll(cwd, message, signal, spawnFn) {
+    // 1. Is this a git work tree at all?
+    const inside = await git(cwd, ['rev-parse', '--is-inside-work-tree'], signal, spawnFn);
+    if (inside.aborted)
+        return { committed: false, reason: 'cancelled' };
+    if (inside.exitCode !== 0 || inside.stdout.trim() !== 'true') {
+        return { committed: false, reason: 'not a git repository' };
+    }
+    // 2. Stage all working-tree changes (new, modified, deleted).
+    const add = await git(cwd, ['add', '-A'], signal, spawnFn);
+    if (add.aborted)
+        return { committed: false, reason: 'cancelled' };
+    if (add.exitCode !== 0) {
+        return { committed: false, reason: `git add failed: ${firstLine(add.stderr)}` };
+    }
+    // 3. Anything staged? `git diff --cached --quiet` exits 0 when the index
+    //    matches HEAD (nothing to commit), 1 when there are staged changes.
+    const diff = await git(cwd, ['diff', '--cached', '--quiet'], signal, spawnFn);
+    if (diff.aborted)
+        return { committed: false, reason: 'cancelled' };
+    if (diff.exitCode === 0)
+        return { committed: false, reason: 'nothing to commit' };
+    // 4. Commit. A failure here is usually missing user.name/user.email config.
+    const commit = await git(cwd, ['commit', '-m', message], signal, spawnFn);
+    if (commit.aborted)
+        return { committed: false, reason: 'cancelled' };
+    if (commit.exitCode !== 0) {
+        return {
+            committed: false,
+            reason: `git commit failed: ${firstLine(commit.stderr || commit.stdout)}`
+        };
+    }
+    return { committed: true };
+}

package/dist/task/auto-io.d.ts

@@ -0,0 +1,17 @@
+export interface TaskEntry {
+    index: number;
+    title: string;
+    done: boolean;
+    producedId?: string;
+}
+export declare function allocateAutoId(cwd: string): Promise<string>;
+/** Parse a decompose-phase model output into a clean list of titles. */
+export declare function parseDecomposeList(raw: string): string[];
+/** Parse the "## tasks" checkbox list. */
+export declare function parseTaskList(body: string): TaskEntry[];
+/** Build the initial AUTO-file body. */
+export declare function buildAutoBody(feature: string, clarifications: string, titles: string[]): string;
+/** Check off the Nth checkbox line, stamping the produced TASK_NNNN id. */
+export declare function checkOffTask(cwd: string, id: string, index: number, producedId: string, title: string): Promise<void>;
+/** Find the most-recently-updated resumable TASK_AUTO_* file, or null. */
+export declare function findResumableAuto(cwd: string): Promise<string | null>;

package/dist/task/auto-io.js

@@ -0,0 +1,124 @@
+/**
+ * AUTO-file I/O & parsing for /task-auto.
+ *
+ * Thin layer over task-io/task-parsers: a TASK_AUTO_NNNN.md is a normal task
+ * file (same front matter) whose body holds feature prompt, clarifications, and
+ * a markdown checkbox list of task titles. The checkboxes are the resume cursor.
+ */
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+import { tasksDir, ensureTasksDir, readTaskFile, setTaskSection } from './task-io.js';
+import { extractSection, parseFrontMatter } from './task-parsers.js';
+import { RESUMABLE_STATES } from './task-types.js';
+const AUTO_FILE_RE = /^(TASK_AUTO_\d{4,})\.md$/;
+const MAX_TASKS = 30;
+export async function allocateAutoId(cwd) {
+    await ensureTasksDir(cwd);
+    const entries = await fsp.readdir(tasksDir(cwd));
+    let max = 0;
+    for (const e of entries) {
+        const m = AUTO_FILE_RE.exec(e);
+        if (m) {
+            const n = parseInt(m[1].slice('TASK_AUTO_'.length), 10);
+            if (n > max)
+                max = n;
+        }
+    }
+    return `TASK_AUTO_${String(max + 1).padStart(4, '0')}`;
+}
+/** Parse a decompose-phase model output into a clean list of titles. */
+export function parseDecomposeList(raw) {
+    const out = [];
+    for (const line of raw.split('\n')) {
+        const m = /^\s*(?:-\s*\[\s*[xX ]?\s*\]\s*|-\s+|\d+[.)]\s+)(.+?)\s*$/.exec(line);
+        if (m && m[1].trim().length > 0)
+            out.push(m[1].trim());
+        if (out.length >= MAX_TASKS)
+            break;
+    }
+    return out;
+}
+const CHECKBOX_RE = /^- \[([ xX])\]\s+(.+?)\s*$/;
+const PRODUCED_ID_RE = /^(TASK_\d{4,})\s{2,}(.+)$/;
+/** Parse the "## tasks" checkbox list. */
+export function parseTaskList(body) {
+    const section = extractSection(body, 'tasks');
+    if (section === null)
+        return [];
+    const entries = [];
+    let index = 0;
+    for (const line of section.split('\n')) {
+        const m = CHECKBOX_RE.exec(line.trim());
+        if (!m)
+            continue;
+        const done = m[1].toLowerCase() === 'x';
+        const rest = m[2].trim();
+        if (done) {
+            const idm = PRODUCED_ID_RE.exec(rest);
+            if (idm) {
+                entries.push({ index, title: idm[2].trim(), done: true, producedId: idm[1] });
+            }
+            else {
+                entries.push({ index, title: rest, done: true });
+            }
+        }
+        else {
+            entries.push({ index, title: rest, done: false });
+        }
+        index++;
+    }
+    return entries;
+}
+/** Build the initial AUTO-file body. */
+export function buildAutoBody(feature, clarifications, titles) {
+    const tasks = titles.map(t => `- [ ] ${t}`).join('\n');
+    return (`\n## feature prompt\n\n${feature.trim() || '(none)'}\n\n`
+        + `## clarifications\n\n${clarifications.trim() || '(none)'}\n\n`
+        + `## tasks\n\n${tasks}\n`);
+}
+/** Check off the Nth checkbox line, stamping the produced TASK_NNNN id. */
+export async function checkOffTask(cwd, id, index, producedId, title) {
+    const { body } = await readTaskFile(cwd, id);
+    const section = extractSection(body, 'tasks') ?? '';
+    const lines = section.split('\n');
+    let seen = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (!CHECKBOX_RE.test(lines[i].trim()))
+            continue;
+        seen++;
+        if (seen === index) {
+            lines[i] = producedId ? `- [x] ${producedId}  ${title}` : `- [x] ${title}`;
+            break;
+        }
+    }
+    if (seen < index) {
+        throw new Error(`checkOffTask: index ${index} out of range in ${id} (only ${seen + 1} checkboxes found)`);
+    }
+    await setTaskSection(cwd, id, 'tasks', lines.join('\n'));
+}
+/** Find the most-recently-updated resumable TASK_AUTO_* file, or null. */
+export async function findResumableAuto(cwd) {
+    await ensureTasksDir(cwd);
+    const entries = await fsp.readdir(tasksDir(cwd));
+    const candidates = [];
+    for (const f of entries) {
+        const m = AUTO_FILE_RE.exec(f);
+        if (!m)
+            continue;
+        try {
+            const raw = await fsp.readFile(path.join(tasksDir(cwd), f), 'utf8');
+            const fm = parseFrontMatter(raw);
+            if (!fm)
+                continue;
+            if (!RESUMABLE_STATES.includes(fm.state))
+                continue;
+            const st = await fsp.stat(path.join(tasksDir(cwd), f));
+            candidates.push({ id: m[1], mtime: st.mtimeMs });
+        }
+        catch {
+            /* skip unreadable */
+        }
+    }
+    candidates.sort((a, b) => b.mtime - a.mtime);
+    return candidates.length > 0 ? candidates[0].id : null;
+}

package/dist/task/auto-orchestrator.d.ts

@@ -0,0 +1,28 @@
+import type { ExtensionAPI, ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
+import type { RunSingleTaskResult } from './orchestrator.js';
+import { type CommitResult } from './auto-commit.js';
+/**
+ * Injectable seams so the planner and loop are testable without spawning pi.
+ * `runChild` is used by planAuto; `runTask` is used by runAutoLoop.
+ */
+export interface AutoDeps {
+    runChild: (name: string, tools: string, prompt: string) => Promise<string>;
+    runTask: (ctx: ExtensionCommandContext, cwd: string, title: string) => Promise<RunSingleTaskResult>;
+    /** Snapshot the working tree into one commit after a task passes. */
+    commit: (cwd: string, message: string) => Promise<CommitResult>;
+}
+/**
+ * Expand any @file references in the feature text by appending each referenced
+ * file's contents, so the planning children (clarify, decompose) always see the
+ * real spec inline instead of relying on the model to open the file itself.
+ * Without this, clarify on a one-line "Implement @spec.md" tends to bail with
+ * NONE because, to the model, the request looks small and unambiguous.
+ * Unreadable mentions (typos, non-file @tokens) are left untouched; the feature
+ * is returned verbatim when nothing readable is referenced.
+ */
+export declare function expandFeatureMentions(cwd: string, feature: string): Promise<string>;
+/** Plan phase: clarify → decompose → write AUTO file. Returns the new id, or null. */
+export declare function planAuto(ctx: ExtensionCommandContext, cwd: string, feature: string, deps: AutoDeps): Promise<string | null>;
+export declare function requestAutoCancel(): void;
+export declare function runAutoLoop(ctx: ExtensionCommandContext, cwd: string, id: string, deps: AutoDeps): Promise<void>;
+export declare function registerTaskAuto(pi: ExtensionAPI): void;