@dreki-gg/pi-plan-mode 0.25.0 → 0.26.1

package/extensions/plan-mode/__tests__/task-status.test.ts

@@ -1,74 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import {
-  activeTasksResolved,
-  deferredTasks,
-  isPlanFinalizable,
-  reactivateForExecution,
-} from '../task-status.js';
-import type { TaskRecord, TaskStatus } from '../types.js';
-
-const now = '2026-05-27T12:00:00.000Z';
-let counter = 0;
-const make = (status: TaskStatus, origin?: 'plan' | 'discovered'): TaskRecord => ({
-  _type: 'task',
-  id: `t-${String(++counter).padStart(3, '0')}`,
-  description: 'task',
-  status,
-  origin,
-  created_at: now,
-  updated_at: now,
-});
-
-describe('deferredTasks', () => {
-  test('returns only deferred tasks', () => {
-    const tasks = [make('done'), make('deferred', 'discovered'), make('pending')];
-    expect(deferredTasks(tasks).map((t) => t.status)).toEqual(['deferred']);
-  });
-});
-
-describe('activeTasksResolved', () => {
-  test('true when only done/skipped/deferred remain', () => {
-    expect(
-      activeTasksResolved([make('done'), make('skipped'), make('deferred', 'discovered')]),
-    ).toBe(true);
-  });
-
-  test('false when a task is still pending', () => {
-    expect(activeTasksResolved([make('done'), make('pending')])).toBe(false);
-  });
-
-  test('false when a task is still blocked', () => {
-    expect(activeTasksResolved([make('done'), make('blocked')])).toBe(false);
-  });
-});
-
-describe('isPlanFinalizable', () => {
-  test('true when all work is done/skipped and nothing is deferred', () => {
-    expect(isPlanFinalizable([make('done'), make('skipped')])).toBe(true);
-  });
-
-  test('false when a deferred follow-up awaits the user', () => {
-    expect(isPlanFinalizable([make('done'), make('deferred', 'discovered')])).toBe(false);
-  });
-
-  test('false when active work remains', () => {
-    expect(isPlanFinalizable([make('pending')])).toBe(false);
-  });
-});
-
-describe('reactivateForExecution', () => {
-  test('flips blocked and deferred tasks to pending and stamps updated_at', () => {
-    const tasks = [make('done'), make('blocked'), make('deferred', 'discovered')];
-    const ts = '2026-06-01T00:00:00.000Z';
-    const changed = reactivateForExecution(tasks, ts);
-    expect(changed).toBe(true);
-    expect(tasks.map((t) => t.status)).toEqual(['done', 'pending', 'pending']);
-    expect(tasks[1].updated_at).toBe(ts);
-    expect(tasks[2].updated_at).toBe(ts);
-  });
-
-  test('returns false and leaves tasks untouched when nothing to reactivate', () => {
-    const tasks = [make('done'), make('pending')];
-    expect(reactivateForExecution(tasks, '2026-06-01T00:00:00.000Z')).toBe(false);
-  });
-});

package/extensions/plan-mode/__tests__/task-storage.test.ts

@@ -1,94 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { Cause, Effect, Exit, Option } from 'effect';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { FileSystem, nodeFileSystemService } from '../effects/filesystem.js';
-import { readTasksJsonl, updateTask, writeTasksJsonl } from '../storage/task-storage.js';
-import type { TaskMeta, TaskRecord } from '../types.js';
-
-const run = <A, E>(program: Effect.Effect<A, E, FileSystem>): Promise<A> =>
-  Effect.runPromise(program.pipe(Effect.provideService(FileSystem, nodeFileSystemService)));
-
-const runExit = <A, E>(program: Effect.Effect<A, E, FileSystem>) =>
-  Effect.runPromiseExit(program.pipe(Effect.provideService(FileSystem, nodeFileSystemService)));
-
-const failureTag = <A, E>(exit: Exit.Exit<A, E>): string | undefined => {
-  if (!Exit.isFailure(exit)) return undefined;
-  const error = Option.getOrUndefined(Cause.failureOption(exit.cause)) as
-    | { _tag?: string }
-    | undefined;
-  return error?._tag;
-};
-
-let dir: string;
-const now = '2026-05-27T12:00:00.000Z';
-const meta: TaskMeta = { _type: 'meta', title: 'Plan', plan_name: 'plan', created_at: now };
-const task: TaskRecord = {
-  _type: 'task',
-  id: 't-001',
-  description: 'Do work',
-  details: 'Details',
-  status: 'pending',
-  created_at: now,
-  updated_at: now,
-};
-
-beforeEach(async () => {
-  dir = await mkdtemp(join(tmpdir(), 'plan-mode-tasks-'));
-});
-afterEach(async () => {
-  await rm(dir, { recursive: true, force: true });
-});
-
-describe('tasks.jsonl storage', () => {
-  test('round trips meta and tasks', async () => {
-    await run(writeTasksJsonl(dir, meta, [task]));
-    await expect(run(readTasksJsonl(dir))).resolves.toEqual({ meta, tasks: [task] });
-  });
-
-  test('round trips tasks without details (lightweight checklist)', async () => {
-    const lightweight: TaskRecord = {
-      _type: 'task',
-      id: 't-002',
-      description: 'Quick fix',
-      status: 'pending',
-      created_at: now,
-      updated_at: now,
-    };
-    await run(writeTasksJsonl(dir, meta, [lightweight]));
-    const result = await run(readTasksJsonl(dir));
-    expect(result?.tasks[0]?.id).toBe('t-002');
-    expect(result?.tasks[0]?.details).toBeUndefined();
-  });
-
-  test('missing file returns undefined', async () => {
-    await expect(run(readTasksJsonl(dir))).resolves.toBeUndefined();
-  });
-
-  test('rejects corrupt lines with JsonlParseError', async () => {
-    await Bun.write(join(dir, 'tasks.jsonl'), `${JSON.stringify(meta)}\nnot-json\n`);
-    expect(failureTag(await runExit(readTasksJsonl(dir)))).toBe('JsonlParseError');
-  });
-
-  test('rejects empty files with MissingMetaRecord', async () => {
-    await Bun.write(join(dir, 'tasks.jsonl'), '');
-    expect(failureTag(await runExit(readTasksJsonl(dir)))).toBe('MissingMetaRecord');
-  });
-
-  test('updates a task by id and rewrites the snapshot', async () => {
-    await run(writeTasksJsonl(dir, meta, [task]));
-    const updated = await run(updateTask(dir, 't-001', { status: 'done', notes: 'finished' }));
-
-    expect(updated.status).toBe('done');
-    expect(updated.notes).toBe('finished');
-    expect((await run(readTasksJsonl(dir)))?.tasks[0]?.status).toBe('done');
-  });
-
-  test('fails with TaskNotFound for an unknown task id', async () => {
-    await run(writeTasksJsonl(dir, meta, [task]));
-    expect(failureTag(await runExit(updateTask(dir, 't-999', { status: 'done' })))).toBe(
-      'TaskNotFound',
-    );
-  });
-});

package/extensions/plan-mode/effects/filesystem.ts

@@ -1,65 +0,0 @@
-/**
- * FileSystem service — the single seam for plan-mode disk I/O.
- *
- * Storage programs depend on this `Context.Tag` rather than touching
- * `node:fs/promises` directly, which makes them trivially testable and keeps
- * all failure modes typed (`PlanReadError` / `PlanWriteError`).
- */
-
-import { Context, Effect } from 'effect';
-import { mkdir, readFile, readdir, unlink, writeFile } from 'node:fs/promises';
-import { PlanReadError, PlanWriteError } from '../errors.js';
-import { writeFileAtomic } from '../storage/atomic-write.js';
-
-export interface FileSystemService {
-  readonly readFileString: (path: string) => Effect.Effect<string, PlanReadError>;
-  readonly writeFileString: (path: string, data: string) => Effect.Effect<void, PlanWriteError>;
-  readonly writeFileAtomic: (path: string, data: string) => Effect.Effect<void, PlanWriteError>;
-  readonly makeDir: (path: string) => Effect.Effect<void, PlanWriteError>;
-  readonly listDirectories: (path: string) => Effect.Effect<string[], PlanReadError>;
-  readonly removeFile: (path: string) => Effect.Effect<void, PlanWriteError>;
-}
-
-export class FileSystem extends Context.Tag('PlanMode/FileSystem')<
-  FileSystem,
-  FileSystemService
->() {}
-
-export const nodeFileSystemService: FileSystemService = {
-  readFileString: (path) =>
-    Effect.tryPromise({
-      try: () => readFile(path, 'utf-8'),
-      catch: (cause) => new PlanReadError({ path, cause }),
-    }),
-
-  writeFileString: (path, data) =>
-    Effect.tryPromise({
-      try: () => writeFile(path, data, 'utf-8'),
-      catch: (cause) => new PlanWriteError({ path, cause }),
-    }),
-
-  writeFileAtomic: (path, data) => writeFileAtomic(path, data),
-
-  makeDir: (path) =>
-    Effect.tryPromise({
-      try: async () => {
-        await mkdir(path, { recursive: true });
-      },
-      catch: (cause) => new PlanWriteError({ path, cause }),
-    }),
-
-  listDirectories: (path) =>
-    Effect.tryPromise({
-      try: async () => {
-        const entries = await readdir(path, { withFileTypes: true });
-        return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-      },
-      catch: (cause) => new PlanReadError({ path, cause }),
-    }),
-
-  removeFile: (path) =>
-    Effect.tryPromise({
-      try: () => unlink(path),
-      catch: (cause) => new PlanWriteError({ path, cause }),
-    }),
-};

package/extensions/plan-mode/effects/runtime.ts

@@ -1,24 +0,0 @@
-/**
- * Live Effect runtime for the plan-mode extension.
- *
- * Build the layer once inside the extension entry and run storage programs
- * through the `runPlanIO` bridge so the imperative pi event handlers keep their
- * `await fn(...)` shape.
- */
-
-import { Effect, Layer } from 'effect';
-import { FileSystem, nodeFileSystemService } from './filesystem.js';
-
-export function makeRuntimeLayer(): Layer.Layer<FileSystem> {
-  return Layer.succeed(FileSystem, nodeFileSystemService);
-}
-
-/** Build a bridge that runs storage programs against the live filesystem layer. */
-export function makePlanRuntime() {
-  const layer = makeRuntimeLayer();
-  return function runPlanIO<A, E>(program: Effect.Effect<A, E, FileSystem>): Promise<A> {
-    return Effect.runPromise(program.pipe(Effect.provide(layer)));
-  };
-}
-
-export type RunPlanIO = ReturnType<typeof makePlanRuntime>;

package/extensions/plan-mode/errors.ts

@@ -1,105 +0,0 @@
-/**
- * Tagged errors for plan-mode disk I/O and JSONL validation.
- *
- * These replace ad-hoc `throw new Error(...)` so storage programs surface
- * typed, inspectable failures. They are mapped back to user-facing strings at
- * the tool boundary via `errorMessage`.
- */
-
-import { Data } from 'effect';
-
-export class PlanReadError extends Data.TaggedError('PlanReadError')<{
-  readonly path: string;
-  readonly cause: unknown;
-}> {
-  get message(): string {
-    return `Failed to read ${this.path}: ${causeMessage(this.cause)}`;
-  }
-}
-
-export class PlanWriteError extends Data.TaggedError('PlanWriteError')<{
-  readonly path: string;
-  readonly cause: unknown;
-}> {
-  get message(): string {
-    return `Failed to write ${this.path}: ${causeMessage(this.cause)}`;
-  }
-}
-
-export class JsonlParseError extends Data.TaggedError('JsonlParseError')<{
-  readonly path: string;
-  readonly line: number;
-  readonly cause?: unknown;
-}> {
-  get message(): string {
-    return `Invalid JSONL in ${this.path} at line ${this.line}: ${causeMessage(this.cause)}`;
-  }
-}
-
-export class JsonlValidationError extends Data.TaggedError('JsonlValidationError')<{
-  readonly path: string;
-  readonly line: number;
-  readonly reason: string;
-}> {
-  get message(): string {
-    return `Invalid record in ${this.path} at line ${this.line}: ${this.reason}`;
-  }
-}
-
-export class MissingMetaRecord extends Data.TaggedError('MissingMetaRecord')<{
-  readonly path: string;
-}> {
-  get message(): string {
-    return `${this.path} is missing meta record`;
-  }
-}
-
-export class TaskNotFound extends Data.TaggedError('TaskNotFound')<{
-  readonly planDir: string;
-  readonly taskId: string;
-}> {
-  get message(): string {
-    return `Task not found: ${this.taskId}`;
-  }
-}
-
-export class TasksFileNotFound extends Data.TaggedError('TasksFileNotFound')<{
-  readonly planDir: string;
-}> {
-  get message(): string {
-    return `No tasks.jsonl found in ${this.planDir}`;
-  }
-}
-
-export type PlanStorageError =
-  | PlanReadError
-  | PlanWriteError
-  | JsonlParseError
-  | JsonlValidationError
-  | MissingMetaRecord
-  | TaskNotFound
-  | TasksFileNotFound;
-
-export function causeMessage(cause: unknown): string {
-  if (cause instanceof Error) return cause.message;
-  return String(cause);
-}
-
-export function errorMessage(error: unknown): string {
-  if (error instanceof Error) return error.message;
-  if (typeof error === 'object' && error !== null && 'message' in error) {
-    const message = (error as { message?: unknown }).message;
-    if (typeof message === 'string') return message;
-  }
-  return String(error);
-}
-
-/** Convert any error (including tagged errors) into a native Error for the tool boundary. */
-export function toNativeError(error: unknown): Error {
-  if (error instanceof Error) return error;
-  const native = new Error(errorMessage(error));
-  if (typeof error === 'object' && error !== null && '_tag' in error) {
-    native.name = String((error as { _tag: unknown })._tag);
-  }
-  return native;
-}

package/extensions/plan-mode/initiative.ts

@@ -1,172 +0,0 @@
-/**
- * Initiative logic — ready-work computation and the initiative→plan projection.
- *
- * Two layers live here:
- *   - PURE: `computePlanReadiness`, `isInitiativeFinalizable`, `initiativeRollup`
- *     reason over a plans-manifest snapshot with no IO. They are the basis for
- *     "what work is unblocked right now" — the foundation for phase-2 subagent
- *     fan-out.
- *   - IO: `reconcileInitiativeStatus` / `reconcileInitiativeForPlan` keep an
- *     initiative's registry status a PROJECTION of its member plans, mirroring
- *     `reconcilePlanStatus` one level up. They read the PLANS manifest, so they
- *     live here (not in `initiatives-manifest.ts`) to keep the dependency
- *     direction one-way: initiative.ts → {plans-manifest, initiatives-manifest}.
- */
-
-import { Effect } from 'effect';
-import { FileSystem } from './effects/filesystem.js';
-import type { JsonlParseError, JsonlValidationError, PlanWriteError } from './errors.js';
-import { readPlansManifest, type PlanManifestEntry } from './storage/plans-manifest.js';
-import {
-  applyInitiativeUpsert,
-  mutateInitiativesManifest,
-} from './storage/initiatives-manifest.js';
-import type { PlanStatus } from './types.js';
-
-// ── Pure: readiness + projection rules ───────────────────────────────────────
-
-export interface PlanReadiness {
-  name: string;
-  /** True when every plan in `depends_on` is `done`. */
-  ready: boolean;
-  /** Dependency plan names that are not yet `done` (unknown deps count too). */
-  blockedBy: string[];
-}
-
-/**
- * For each `in-progress` plan, whether all of its plan-level dependencies are
- * `done`. Only a `done` dependency unblocks — a missing, in-progress, or
- * terminally-closed (superseded/abandoned) dependency keeps a plan blocked.
- */
-export function computePlanReadiness(plans: readonly PlanManifestEntry[]): PlanReadiness[] {
-  const statusByName = new Map(plans.map((plan) => [plan.name, plan.status]));
-  return plans
-    .filter((plan) => plan.status === 'in-progress')
-    .map((plan) => {
-      const deps = plan.depends_on ?? [];
-      const blockedBy = deps.filter((dep) => statusByName.get(dep) !== 'done');
-      return { name: plan.name, ready: blockedBy.length === 0, blockedBy };
-    });
-}
-
-/** Member plans of an initiative (linked by name in the plans manifest). */
-export function membersOf(
-  initiative: string,
-  plans: readonly PlanManifestEntry[],
-): PlanManifestEntry[] {
-  return plans.filter((plan) => plan.initiative === initiative);
-}
-
-/**
- * An initiative is finalizable (`done`) when it has ≥1 member plan AND every
- * member is terminal (no member is `in-progress`). Mirrors the plan-level rule
- * one level up.
- */
-export function isInitiativeFinalizable(
-  initiative: string,
-  plans: readonly PlanManifestEntry[],
-): boolean {
-  const members = membersOf(initiative, plans);
-  if (members.length === 0) return false;
-  return members.every((plan) => plan.status !== 'in-progress');
-}
-
-export interface InitiativeMemberRow {
-  name: string;
-  title: string;
-  status: PlanStatus;
-  /** Present for in-progress members. */
-  ready?: boolean;
-  blockedBy?: string[];
-}
-
-export interface InitiativeRollup {
-  name: string;
-  total: number;
-  done: number;
-  /** Terminal but not done (superseded / abandoned). */
-  closed: number;
-  inProgress: number;
-  ready: number;
-  blocked: number;
-  members: InitiativeMemberRow[];
-}
-
-/** Aggregate an initiative's member plans into counts + per-member readiness. */
-export function initiativeRollup(
-  initiative: string,
-  plans: readonly PlanManifestEntry[],
-): InitiativeRollup {
-  const members = membersOf(initiative, plans);
-  const readiness = new Map(computePlanReadiness(plans).map((row) => [row.name, row]));
-
-  let done = 0;
-  let closed = 0;
-  let inProgress = 0;
-  let ready = 0;
-  let blocked = 0;
-
-  const rows: InitiativeMemberRow[] = members.map((plan) => {
-    if (plan.status === 'done') done += 1;
-    else if (plan.status === 'in-progress') inProgress += 1;
-    else closed += 1; // superseded / abandoned
-
-    const row: InitiativeMemberRow = { name: plan.name, title: plan.title, status: plan.status };
-    if (plan.status === 'in-progress') {
-      const r = readiness.get(plan.name);
-      row.ready = r?.ready ?? true;
-      row.blockedBy = r?.blockedBy ?? [];
-      if (row.ready) ready += 1;
-      else blocked += 1;
-    }
-    return row;
-  });
-
-  return { name: initiative, total: members.length, done, closed, inProgress, ready, blocked, members: rows };
-}
-
-// ── IO: keep initiative registry status a projection of member plans ─────────
-
-type ReconcileError = JsonlParseError | JsonlValidationError | PlanWriteError;
-
-/**
- * Re-derive an initiative's registry status from its member plans.
- *
- * Like `reconcilePlanStatus`: only reflects state for a KNOWN initiative (never
- * conjures an entry), and never clobbers a manually-set terminal status
- * (`superseded` / `abandoned`). Only `in-progress` ⇄ `done` is derived.
- */
-export function reconcileInitiativeStatus(
-  name: string,
-): Effect.Effect<void, ReconcileError, FileSystem> {
-  // The whole read-decide-write runs under the initiatives lock so a concurrent
-  // writer cannot slip a status change between our read and our write.
-  return mutateInitiativesManifest((initiatives) =>
-    Effect.gen(function* () {
-      const existing = initiatives.find((entry) => entry.name === name);
-      if (!existing) return false;
-      if (existing.status === 'superseded' || existing.status === 'abandoned') return false;
-      const plans = yield* readPlansManifest();
-      const status: PlanStatus = isInitiativeFinalizable(name, plans) ? 'done' : 'in-progress';
-      if (existing.status === status) return false;
-      applyInitiativeUpsert(initiatives, name, { status, title: existing.title });
-      return true;
-    }),
-  );
-}
-
-/**
- * Reconcile the initiative that a given plan belongs to (no-op when the plan is
- * standalone). Call this after any plan-status write so the initiative level
- * stays in sync without callers needing to know the parent name.
- */
-export function reconcileInitiativeForPlan(
-  planName: string,
-): Effect.Effect<void, ReconcileError, FileSystem> {
-  return Effect.gen(function* () {
-    const plans = yield* readPlansManifest();
-    const plan = plans.find((entry) => entry.name === planName);
-    if (!plan?.initiative) return;
-    yield* reconcileInitiativeStatus(plan.initiative);
-  });
-}

package/extensions/plan-mode/plan-storage.ts

@@ -1,6 +0,0 @@
-export {
-  loadHandoff,
-  readAndClearExecPending,
-  saveHandoff,
-  writeExecPending,
-} from './storage/plan-storage.js';