@ilya-lesikov/pi-pi 0.1.0

package/3p/pi-tasks/src/process-tracker.ts

@@ -0,0 +1,140 @@
+/**
+ * process-tracker.ts — Background process management for tasks.
+ *
+ * Tracks spawned child processes, buffers their output, and supports
+ * blocking wait and graceful stop (SIGTERM → 5s → SIGKILL).
+ */
+
+import type { ChildProcess } from "node:child_process";
+import type { BackgroundProcess } from "./types.js";
+
+export interface ProcessOutput {
+  output: string;
+  status: BackgroundProcess["status"];
+  exitCode?: number;
+  startedAt: number;
+  completedAt?: number;
+  command?: string;
+}
+
+export class ProcessTracker {
+  private processes = new Map<string, BackgroundProcess>();
+
+  /** Register a spawned process for a task. */
+  track(taskId: string, proc: ChildProcess, command?: string): void {
+    const bp: BackgroundProcess = {
+      taskId,
+      pid: proc.pid!,
+      command,
+      output: [],
+      status: "running",
+      startedAt: Date.now(),
+      proc,
+      abortController: new AbortController(),
+      waiters: [],
+    };
+
+    // Buffer stdout
+    proc.stdout?.on("data", (data: Buffer) => {
+      bp.output.push(data.toString());
+    });
+
+    // Buffer stderr
+    proc.stderr?.on("data", (data: Buffer) => {
+      bp.output.push(data.toString());
+    });
+
+    // Handle process exit
+    proc.on("close", (code, _signal) => {
+      if (bp.status === "running") {
+        bp.status = code === 0 ? "completed" : "error";
+      }
+      bp.exitCode = code ?? undefined;
+      bp.completedAt = Date.now();
+      // Notify all waiters
+      for (const resolve of bp.waiters) resolve();
+      bp.waiters = [];
+    });
+
+    proc.on("error", (err) => {
+      if (bp.status === "running") {
+        bp.status = "error";
+        bp.output.push(`Process error: ${err.message}`);
+        bp.completedAt = Date.now();
+        for (const resolve of bp.waiters) resolve();
+        bp.waiters = [];
+      }
+    });
+
+    this.processes.set(taskId, bp);
+  }
+
+  /** Get current output and status for a task's process. */
+  getOutput(taskId: string): ProcessOutput | undefined {
+    const bp = this.processes.get(taskId);
+    if (!bp) return undefined;
+    return {
+      output: bp.output.join(""),
+      status: bp.status,
+      exitCode: bp.exitCode,
+      startedAt: bp.startedAt,
+      completedAt: bp.completedAt,
+      command: bp.command,
+    };
+  }
+
+  /** Wait for a task's process to complete, with timeout. */
+  waitForCompletion(taskId: string, timeout: number, signal?: AbortSignal): Promise<ProcessOutput | undefined> {
+    const bp = this.processes.get(taskId);
+    if (!bp) return Promise.resolve(undefined);
+    if (bp.status !== "running") return Promise.resolve(this.getOutput(taskId));
+
+    return new Promise<ProcessOutput | undefined>((resolve) => {
+      let settled = false;
+      const timer = setTimeout(finish, timeout);
+
+      function finish() {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve(self.getOutput(taskId));
+      }
+
+      const self = this;
+      bp.waiters.push(finish);
+      signal?.addEventListener("abort", finish, { once: true });
+    });
+  }
+
+  /** Stop a task's background process. SIGTERM → 5s → SIGKILL. */
+  async stop(taskId: string): Promise<boolean> {
+    const bp = this.processes.get(taskId);
+    if (!bp || bp.status !== "running") return false;
+
+    bp.status = "stopped";
+    bp.proc.kill("SIGTERM");
+
+    // Wait up to 5s for graceful exit
+    await new Promise<void>((resolve) => {
+      const timer = setTimeout(() => {
+        try { bp.proc.kill("SIGKILL"); } catch { /* already dead */ }
+        resolve();
+      }, 5000);
+
+      bp.proc.on("close", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+
+    bp.completedAt = Date.now();
+    for (const resolve of bp.waiters) resolve();
+    bp.waiters = [];
+    return true;
+  }
+
+  /** Get the process record for a task. */
+  getProcess(taskId: string): BackgroundProcess | undefined {
+    return this.processes.get(taskId);
+  }
+}

package/3p/pi-tasks/src/reminder-cadence.ts

@@ -0,0 +1,90 @@
+/**
+ * Pure cadence logic for the system-reminder injection.
+ *
+ * Decisions are made here as plain functions so they're easy to unit-test
+ * without spinning up the whole extension. The default export of the
+ * extension wires these into the `tool_result` and `context` hooks.
+ */
+
+/** Internal cadence state. Plain object so it round-trips through tests. */
+export interface CadenceState {
+  currentTurn: number;
+  lastTaskToolUseTurn: number;
+  reminderInjectedThisCycle: boolean;
+  reminderDue: boolean;
+}
+
+export interface CadenceConfig {
+  /** Turns without a task-tool call before a reminder is considered due. */
+  reminderInterval: number;
+  /** Set of tool names that count as "task tool usage" and reset cadence. */
+  taskToolNames: ReadonlySet<string>;
+}
+
+export function createCadenceState(): CadenceState {
+  return {
+    currentTurn: 0,
+    lastTaskToolUseTurn: 0,
+    reminderInjectedThisCycle: false,
+    reminderDue: false,
+  };
+}
+
+export function resetCadenceState(state: CadenceState): void {
+  state.currentTurn = 0;
+  state.lastTaskToolUseTurn = 0;
+  state.reminderInjectedThisCycle = false;
+  state.reminderDue = false;
+}
+
+/** Increment the turn counter at `turn_start`. */
+export function onTurnStart(state: CadenceState): void {
+  state.currentTurn++;
+}
+
+export interface ToolResultDecision {
+  /** True when caller should mark `reminderDue` for the next `context` event. */
+  markDue: boolean;
+}
+
+/**
+ * Decide what cadence change a tool_result implies. Mutates `state` in place
+ * (resets the timer when a task tool was used) and returns whether the
+ * reminder should be queued for the next LLM call.
+ */
+export function evaluateToolResult(
+  state: CadenceState,
+  toolName: string,
+  hasTasks: boolean,
+  config: CadenceConfig,
+): ToolResultDecision {
+  // Task tool usage resets cadence and clears any pending reminder.
+  if (config.taskToolNames.has(toolName)) {
+    state.lastTaskToolUseTurn = state.currentTurn;
+    state.reminderInjectedThisCycle = false;
+    state.reminderDue = false;
+    return { markDue: false };
+  }
+
+  // Cheap guards first.
+  if (state.currentTurn - state.lastTaskToolUseTurn < config.reminderInterval) {
+    return { markDue: false };
+  }
+  if (state.reminderInjectedThisCycle) return { markDue: false };
+  if (!hasTasks) return { markDue: false };
+
+  state.reminderDue = true;
+  return { markDue: true };
+}
+
+/**
+ * Drain the pending reminder when `context` fires. Returns true if the
+ * caller should inject the reminder into the upcoming LLM call's messages.
+ */
+export function drainReminderForContext(state: CadenceState): boolean {
+  if (!state.reminderDue) return false;
+  state.reminderDue = false;
+  state.reminderInjectedThisCycle = true;
+  state.lastTaskToolUseTurn = state.currentTurn;
+  return true;
+}

package/3p/pi-tasks/src/task-store.ts

@@ -0,0 +1,324 @@
+/**
+ * task-store.ts — File-backed task store with CRUD, dependency management, and file locking.
+ *
+ * Session-scoped (default): in-memory Map — no disk I/O.
+ * Shared (PI_TASK_LIST_ID set): ~/.pi/tasks/<listId>.json with file locking.
+ */
+
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join } from "node:path";
+import type { Task, TaskStatus, TaskStoreData } from "./types.js";
+
+function sortById(a: Task, b: Task): number {
+  return Number(a.id) - Number(b.id);
+}
+
+function sortByStatus(a: Task, b: Task): number {
+  const rank = (s: string) => s === "completed" ? 0 : s === "in_progress" ? 1 : 2;
+  return rank(a.status) - rank(b.status) || Number(a.id) - Number(b.id);
+}
+
+function sortByRecent(a: Task, b: Task): number {
+  return b.updatedAt - a.updatedAt || Number(b.id) - Number(a.id);
+}
+
+function sortByOldest(a: Task, b: Task): number {
+  return a.updatedAt - b.updatedAt || Number(a.id) - Number(b.id);
+}
+
+const SORT_FNS = { id: sortById, status: sortByStatus, recent: sortByRecent, oldest: sortByOldest };
+
+const TASKS_DIR = join(homedir(), ".pi", "tasks");
+const LOCK_RETRY_MS = 50;
+const LOCK_MAX_RETRIES = 100; // 5s max
+
+/** Simple file-based locking. */
+function acquireLock(lockPath: string): void {
+  for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
+    try {
+      // O_EXCL: fail if file exists
+      writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
+      return;
+    } catch (e: any) {
+      if (e.code === "EEXIST") {
+        // Check for stale lock (process no longer running)
+        try {
+          const pid = parseInt(readFileSync(lockPath, "utf-8"), 10);
+          if (pid && !isProcessRunning(pid)) {
+            unlinkSync(lockPath);
+            continue;
+          }
+        } catch { /* ignore read errors */ }
+        // Wait and retry
+        const start = Date.now();
+        while (Date.now() - start < LOCK_RETRY_MS) { /* busy wait */ }
+        continue;
+      }
+      throw e;
+    }
+  }
+  throw new Error(`Failed to acquire lock: ${lockPath}`);
+}
+
+function releaseLock(lockPath: string): void {
+  try { unlinkSync(lockPath); } catch { /* ignore */ }
+}
+
+function isProcessRunning(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+export class TaskStore {
+  private filePath: string | undefined;
+  private lockPath: string | undefined;
+
+  // In-memory state (always kept in sync)
+  private nextId = 1;
+  private tasks = new Map<string, Task>();
+
+  constructor(listIdOrPath?: string) {
+    if (!listIdOrPath) return;
+    const isAbsPath = isAbsolute(listIdOrPath);
+    const filePath = isAbsPath ? listIdOrPath : join(TASKS_DIR, `${listIdOrPath}.json`);
+    mkdirSync(dirname(filePath), { recursive: true });
+    this.filePath = filePath;
+    this.lockPath = filePath + ".lock";
+    this.load();
+  }
+
+  /** Read store from disk (file-backed mode only). */
+  private load(): void {
+    if (!this.filePath) return;
+    if (!existsSync(this.filePath)) return;
+    try {
+      const data: TaskStoreData = JSON.parse(readFileSync(this.filePath, "utf-8"));
+      this.nextId = data.nextId;
+      this.tasks.clear();
+      for (const t of data.tasks) {
+        this.tasks.set(t.id, t);
+      }
+    } catch { /* corrupt file — start fresh */ }
+  }
+
+  /** Write store to disk atomically (file-backed mode only). */
+  private save(): void {
+    if (!this.filePath) return;
+    const data: TaskStoreData = {
+      nextId: this.nextId,
+      tasks: Array.from(this.tasks.values()),
+    };
+    const tmpPath = this.filePath + ".tmp";
+    writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+    renameSync(tmpPath, this.filePath);
+  }
+
+  /** Execute a mutation with file locking (if file-backed). */
+  private withLock<T>(fn: () => T): T {
+    if (!this.lockPath) return fn();
+    acquireLock(this.lockPath);
+    try {
+      this.load(); // Re-read latest state
+      const result = fn();
+      this.save();
+      return result;
+    } finally {
+      releaseLock(this.lockPath);
+    }
+  }
+
+  create(subject: string, description: string, activeForm?: string, metadata?: Record<string, any>): Task {
+    return this.withLock(() => {
+      const now = Date.now();
+      const task: Task = {
+        id: String(this.nextId++),
+        subject,
+        description,
+        status: "pending",
+        activeForm,
+        owner: undefined,
+        metadata: metadata ?? {},
+        blocks: [],
+        blockedBy: [],
+        createdAt: now,
+        updatedAt: now,
+      };
+      this.tasks.set(task.id, task);
+      return task;
+    });
+  }
+
+  get(id: string): Task | undefined {
+    if (this.filePath) this.load();
+    return this.tasks.get(id);
+  }
+
+  /** List all tasks, sorted by the given order (defaults to ID ascending). */
+  list(sortOrder: "id" | "status" | "recent" | "oldest" = "id"): Task[] {
+    if (this.filePath) this.load();
+    return Array.from(this.tasks.values()).sort(SORT_FNS[sortOrder]);
+  }
+
+  update(id: string, fields: {
+    status?: TaskStatus | "deleted";
+    subject?: string;
+    description?: string;
+    activeForm?: string;
+    owner?: string;
+    metadata?: Record<string, any>;
+    addBlocks?: string[];
+    addBlockedBy?: string[];
+  }): { task: Task | undefined; changedFields: string[]; warnings: string[] } {
+    return this.withLock(() => {
+      const task = this.tasks.get(id);
+      if (!task) return { task: undefined, changedFields: [], warnings: [] };
+
+      const changedFields: string[] = [];
+      const warnings: string[] = [];
+
+      // Handle deletion
+      if (fields.status === "deleted") {
+        this.tasks.delete(id);
+        // Clean up dependency edges pointing to this task
+        for (const t of this.tasks.values()) {
+          t.blocks = t.blocks.filter(bid => bid !== id);
+          t.blockedBy = t.blockedBy.filter(bid => bid !== id);
+        }
+        return { task: undefined, changedFields: ["deleted"], warnings: [] };
+      }
+
+      if (fields.status !== undefined) {
+        task.status = fields.status;
+        changedFields.push("status");
+      }
+      if (fields.subject !== undefined) {
+        task.subject = fields.subject;
+        changedFields.push("subject");
+      }
+      if (fields.description !== undefined) {
+        task.description = fields.description;
+        changedFields.push("description");
+      }
+      if (fields.activeForm !== undefined) {
+        task.activeForm = fields.activeForm;
+        changedFields.push("activeForm");
+      }
+      if (fields.owner !== undefined) {
+        task.owner = fields.owner;
+        changedFields.push("owner");
+      }
+
+      // Metadata: shallow merge, null deletes keys
+      if (fields.metadata !== undefined) {
+        for (const [key, value] of Object.entries(fields.metadata)) {
+          if (value === null) {
+            delete task.metadata[key];
+          } else {
+            task.metadata[key] = value;
+          }
+        }
+        changedFields.push("metadata");
+      }
+
+      // Bidirectional dependency edges
+      if (fields.addBlocks && fields.addBlocks.length > 0) {
+        for (const targetId of fields.addBlocks) {
+          if (!task.blocks.includes(targetId)) {
+            task.blocks.push(targetId);
+          }
+          const target = this.tasks.get(targetId);
+          if (target && !target.blockedBy.includes(id)) {
+            target.blockedBy.push(id);
+            target.updatedAt = Date.now();
+          }
+          // Warnings for problematic edges
+          if (targetId === id) {
+            warnings.push(`#${id} blocks itself`);
+          } else if (!target) {
+            warnings.push(`#${targetId} does not exist`);
+          } else if (target.blocks.includes(id)) {
+            warnings.push(`cycle: #${id} and #${targetId} block each other`);
+          }
+        }
+        changedFields.push("blocks");
+      }
+
+      if (fields.addBlockedBy && fields.addBlockedBy.length > 0) {
+        for (const targetId of fields.addBlockedBy) {
+          if (!task.blockedBy.includes(targetId)) {
+            task.blockedBy.push(targetId);
+          }
+          const target = this.tasks.get(targetId);
+          if (target && !target.blocks.includes(id)) {
+            target.blocks.push(id);
+            target.updatedAt = Date.now();
+          }
+          // Warnings for problematic edges
+          if (targetId === id) {
+            warnings.push(`#${id} blocks itself`);
+          } else if (!target) {
+            warnings.push(`#${targetId} does not exist`);
+          } else if (task.blocks.includes(targetId)) {
+            warnings.push(`cycle: #${id} and #${targetId} block each other`);
+          }
+        }
+        changedFields.push("blockedBy");
+      }
+
+      task.updatedAt = Date.now();
+      return { task, changedFields, warnings };
+    });
+  }
+
+  /** Delete a task by ID. Returns true if deleted. */
+  delete(id: string): boolean {
+    return this.withLock(() => {
+      if (!this.tasks.has(id)) return false;
+      this.tasks.delete(id);
+      // Clean up dependency edges
+      for (const t of this.tasks.values()) {
+        t.blocks = t.blocks.filter(bid => bid !== id);
+        t.blockedBy = t.blockedBy.filter(bid => bid !== id);
+      }
+      return true;
+    });
+  }
+
+  /** Remove all tasks. */
+  clearAll(): number {
+    return this.withLock(() => {
+      const count = this.tasks.size;
+      this.tasks.clear();
+      return count;
+    });
+  }
+
+  /** Delete the backing file (if file-backed and empty). */
+  deleteFileIfEmpty(): boolean {
+    if (!this.filePath || this.tasks.size > 0) return false;
+    try { unlinkSync(this.filePath); } catch { /* ignore */ }
+    return true;
+  }
+
+  /** Remove all completed tasks. */
+  clearCompleted(): number {
+    return this.withLock(() => {
+      let count = 0;
+      for (const [id, task] of this.tasks) {
+        if (task.status === "completed") {
+          this.tasks.delete(id);
+          count++;
+        }
+      }
+      // Clean up dependency edges for deleted tasks
+      if (count > 0) {
+        const validIds = new Set(this.tasks.keys());
+        for (const t of this.tasks.values()) {
+          t.blocks = t.blocks.filter(bid => validIds.has(bid));
+          t.blockedBy = t.blockedBy.filter(bid => validIds.has(bid));
+        }
+      }
+      return count;
+    });
+  }
+}

package/3p/pi-tasks/src/tasks-config.ts

@@ -0,0 +1,27 @@
+// <cwd>/.pi/tasks-config.json — persists extension settings across sessions
+
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+export interface TasksConfig {
+  taskScope?: "memory" | "session" | "project";  // default: "session"
+  autoCascade?: boolean;   // default: false
+  autoClearCompleted?: "never" | "on_list_complete" | "on_task_complete";  // default: "on_list_complete"
+  showAll?: boolean;                     // default: false
+  maxVisible?: number;                   // default: 10
+  sortOrder?: "id" | "status" | "recent" | "oldest";  // default: "id"
+  hiddenAt?: "top" | "bottom";                         // default: "bottom"
+}
+
+const CONFIG_PATH = join(process.cwd(), ".pi", "tasks-config.json");
+
+export function loadTasksConfig(): TasksConfig {
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  } catch { return {}; }
+}
+
+export function saveTasksConfig(config: TasksConfig): void {
+  mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}

package/3p/pi-tasks/src/types.ts

@@ -0,0 +1,40 @@
+/**
+ * types.ts — Type definitions for the task management system.
+ */
+
+export type TaskStatus = "pending" | "in_progress" | "completed";
+
+export interface Task {
+  id: string;
+  subject: string;
+  description: string;
+  status: TaskStatus;
+  activeForm?: string;
+  owner?: string;
+  metadata: Record<string, any>;
+  blocks: string[];
+  blockedBy: string[];
+  createdAt: number;
+  updatedAt: number;
+}
+
+/** Serialized store format on disk. */
+export interface TaskStoreData {
+  nextId: number;
+  tasks: Task[];
+}
+
+/** Background process associated with a task. */
+export interface BackgroundProcess {
+  taskId: string;
+  pid: number;
+  command?: string;
+  output: string[];
+  status: "running" | "completed" | "error" | "stopped";
+  exitCode?: number;
+  startedAt: number;
+  completedAt?: number;
+  proc: import("node:child_process").ChildProcess;
+  abortController: AbortController;
+  waiters: Array<() => void>;
+}