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

package/extensions/plan-mode/__tests__/initiatives-manifest.test.ts

@@ -1,89 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { Effect } from 'effect';
-import { chdir } from 'node:process';
-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 {
-  readInitiativesManifest,
-  upsertInitiativeEntry,
-  writeInitiativesManifest,
-} from '../storage/initiatives-manifest.js';
-
-const run = <A, E>(program: Effect.Effect<A, E, FileSystem>): Promise<A> =>
-  Effect.runPromise(program.pipe(Effect.provideService(FileSystem, nodeFileSystemService)));
-
-const originalCwd = process.cwd();
-let dir: string;
-
-beforeEach(async () => {
-  dir = await mkdtemp(join(tmpdir(), 'plan-mode-initiatives-'));
-  chdir(dir);
-});
-afterEach(async () => {
-  chdir(originalCwd);
-  await rm(dir, { recursive: true, force: true });
-});
-
-describe('initiatives.jsonl manifest', () => {
-  test('round trips entries', async () => {
-    const entry = {
-      _type: 'initiative' as const,
-      name: 'auth-overhaul',
-      status: 'in-progress' as const,
-      title: 'Auth Overhaul',
-      created_at: 'now',
-      completed_at: null,
-    };
-    await run(writeInitiativesManifest([entry]));
-    await expect(run(readInitiativesManifest())).resolves.toEqual([entry]);
-  });
-
-  test('missing manifest returns an empty list', async () => {
-    await expect(run(readInitiativesManifest())).resolves.toEqual([]);
-  });
-
-  test('upserts new entries', async () => {
-    await run(upsertInitiativeEntry('big-thing', { status: 'in-progress', title: 'Big Thing' }));
-    const entries = await run(readInitiativesManifest());
-    expect(entries).toHaveLength(1);
-    expect(entries[0]?.name).toBe('big-thing');
-    expect(entries[0]?.title).toBe('Big Thing');
-    expect(entries[0]?.completed_at).toBeNull();
-  });
-
-  test('upserts existing entries without changing created_at', async () => {
-    await run(
-      writeInitiativesManifest([
-        {
-          _type: 'initiative',
-          name: 'i',
-          status: 'in-progress',
-          title: 'Old',
-          created_at: 'created',
-          completed_at: null,
-        },
-      ]),
-    );
-    await run(upsertInitiativeEntry('i', { status: 'done', title: 'New' }));
-    const [entry] = await run(readInitiativesManifest());
-    expect(entry.created_at).toBe('created');
-    expect(entry.status).toBe('done');
-    expect(entry.completed_at).toBeString();
-  });
-
-  test('records a reason for terminal statuses and clears completed_at on reopen', async () => {
-    await run(upsertInitiativeEntry('i', { status: 'in-progress', title: 'I' }));
-    await run(upsertInitiativeEntry('i', { status: 'superseded', reason: 'merged into j' }));
-    let [entry] = await run(readInitiativesManifest());
-    expect(entry.status).toBe('superseded');
-    expect(entry.reason).toBe('merged into j');
-    expect(entry.completed_at).toBeString();
-
-    await run(upsertInitiativeEntry('i', { status: 'in-progress' }));
-    [entry] = await run(readInitiativesManifest());
-    expect(entry.status).toBe('in-progress');
-    expect(entry.completed_at).toBeNull();
-  });
-});

package/extensions/plan-mode/__tests__/list-initiatives.test.ts

@@ -1,59 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { chdir } from 'node:process';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { makePlanRuntime } from '../effects/runtime.js';
-import { upsertPlanEntry } from '../storage/plans-manifest.js';
-import { upsertInitiativeEntry } from '../storage/initiatives-manifest.js';
-import {
-  filterInitiatives,
-  formatInitiativeList,
-  loadInitiativeListItems,
-  parseFilter,
-} from '../commands/list-initiatives.js';
-
-const runPlanIO = makePlanRuntime();
-
-const originalCwd = process.cwd();
-let dir: string;
-beforeEach(async () => {
-  dir = await mkdtemp(join(tmpdir(), 'plan-mode-list-init-'));
-  chdir(dir);
-});
-afterEach(async () => {
-  chdir(originalCwd);
-  await rm(dir, { recursive: true, force: true });
-});
-
-describe('list-initiatives', () => {
-  test('parseFilter maps aliases', () => {
-    expect(parseFilter('done')).toBe('done');
-    expect(parseFilter('active')).toBe('in-progress');
-    expect(parseFilter('whatever')).toBe('all');
-  });
-
-  test('rolls up member-plan progress and readiness', async () => {
-    await runPlanIO(upsertInitiativeEntry('big', { status: 'in-progress', title: 'Big' }));
-    await runPlanIO(upsertPlanEntry('a', { status: 'done', title: 'A', initiative: 'big' }));
-    await runPlanIO(
-      upsertPlanEntry('b', { status: 'in-progress', title: 'B', initiative: 'big', depends_on: ['a'] }),
-    );
-
-    const items = await runPlanIO(loadInitiativeListItems());
-    expect(items).toHaveLength(1);
-    expect(items[0]?.totalPlans).toBe(2);
-    expect(items[0]?.donePlans).toBe(1);
-    expect(items[0]?.ready).toBe(1); // b unblocked (a done)
-
-    const text = formatInitiativeList(items, 'all');
-    expect(text).toMatch(/big — Big \[1\/2 plans, ready 1, blocked 0\]/);
-  });
-
-  test('filterInitiatives narrows by status', async () => {
-    await runPlanIO(upsertInitiativeEntry('x', { status: 'in-progress', title: 'X' }));
-    await runPlanIO(upsertInitiativeEntry('y', { status: 'done', title: 'Y' }));
-    const items = await runPlanIO(loadInitiativeListItems());
-    expect(filterInitiatives(items, 'done').map((i) => i.name)).toEqual(['y']);
-  });
-});

package/extensions/plan-mode/__tests__/list-plans.test.ts

@@ -1,253 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { chdir } from 'node:process';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { makePlanRuntime } from '../effects/runtime.js';
-import { upsertPlanEntry } from '../storage/plans-manifest.js';
-import { writeTasksJsonl } from '../storage/task-storage.js';
-import type { TaskMeta, TaskRecord, PlanStatus } from '../types.js';
-import {
-  filterPlans,
-  sortPlans,
-  formatPlanList,
-  parseArgs,
-  loadPlanListItems,
-  type PlanListItem,
-  type SortField,
-  type StatusFilter,
-} from '../commands/list-plans.js';
-
-const runPlanIO = makePlanRuntime();
-const originalCwd = process.cwd();
-let dir: string;
-
-beforeEach(async () => {
-  dir = await mkdtemp(join(tmpdir(), 'plan-mode-list-'));
-  chdir(dir);
-});
-
-afterEach(async () => {
-  chdir(originalCwd);
-  await rm(dir, { recursive: true, force: true });
-});
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-const meta = (name: string): TaskMeta => ({
-  _type: 'meta',
-  title: `Title ${name}`,
-  plan_name: name,
-  created_at: '2026-01-01T00:00:00.000Z',
-});
-
-const task = (id: string, status: 'done' | 'pending' = 'done'): TaskRecord => ({
-  _type: 'task',
-  id,
-  description: `task ${id}`,
-  status,
-  origin: 'plan',
-  created_at: '2026-01-01T00:00:00.000Z',
-  updated_at: '2026-01-01T00:00:00.000Z',
-});
-
-function makePlanItem(overrides: Partial<PlanListItem> & { name: string }): PlanListItem {
-  return {
-    title: `Title ${overrides.name}`,
-    status: 'in-progress',
-    created_at: '2026-01-01T00:00:00.000Z',
-    completed_at: null,
-    totalTasks: 3,
-    doneTasks: 1,
-    pendingTasks: 2,
-    ...overrides,
-  };
-}
-
-// ── filterPlans ──────────────────────────────────────────────────────────────
-
-describe('filterPlans', () => {
-  const plans: PlanListItem[] = [
-    makePlanItem({ name: 'alpha', status: 'in-progress' }),
-    makePlanItem({ name: 'beta', status: 'done' }),
-    makePlanItem({ name: 'gamma', status: 'abandoned' }),
-  ];
-
-  test('returns all when filter is "all"', () => {
-    expect(filterPlans(plans, 'all')).toHaveLength(3);
-  });
-
-  test('filters by in-progress', () => {
-    const result = filterPlans(plans, 'in-progress');
-    expect(result).toHaveLength(1);
-    expect(result[0].name).toBe('alpha');
-  });
-
-  test('filters by done', () => {
-    const result = filterPlans(plans, 'done');
-    expect(result).toHaveLength(1);
-    expect(result[0].name).toBe('beta');
-  });
-
-  test('filters by abandoned', () => {
-    const result = filterPlans(plans, 'abandoned');
-    expect(result).toHaveLength(1);
-    expect(result[0].name).toBe('gamma');
-  });
-
-  test('returns empty when no match', () => {
-    expect(filterPlans(plans, 'superseded')).toHaveLength(0);
-  });
-});
-
-// ── sortPlans ────────────────────────────────────────────────────────────────
-
-describe('sortPlans', () => {
-  const plans: PlanListItem[] = [
-    makePlanItem({ name: 'charlie', created_at: '2026-03-01T00:00:00.000Z', totalTasks: 2 }),
-    makePlanItem({ name: 'alpha', created_at: '2026-01-01T00:00:00.000Z', totalTasks: 5 }),
-    makePlanItem({ name: 'bravo', created_at: '2026-02-01T00:00:00.000Z', totalTasks: 1 }),
-  ];
-
-  test('sorts by name', () => {
-    const result = sortPlans(plans, 'name');
-    expect(result.map((p) => p.name)).toEqual(['alpha', 'bravo', 'charlie']);
-  });
-
-  test('sorts by date ascending (oldest first)', () => {
-    const result = sortPlans(plans, 'date-asc');
-    expect(result.map((p) => p.name)).toEqual(['alpha', 'bravo', 'charlie']);
-  });
-
-  test('sorts by date descending (newest first)', () => {
-    const result = sortPlans(plans, 'date-desc');
-    expect(result.map((p) => p.name)).toEqual(['charlie', 'bravo', 'alpha']);
-  });
-
-  test('sorts by task count (most tasks first)', () => {
-    const result = sortPlans(plans, 'tasks');
-    expect(result.map((p) => p.name)).toEqual(['alpha', 'charlie', 'bravo']);
-  });
-
-  test('does not mutate the original array', () => {
-    const original = [...plans];
-    sortPlans(plans, 'name');
-    expect(plans.map((p) => p.name)).toEqual(original.map((p) => p.name));
-  });
-});
-
-// ── formatPlanList ───────────────────────────────────────────────────────────
-
-describe('formatPlanList', () => {
-  test('shows message when empty and filter is all', () => {
-    expect(formatPlanList([], 'all', 'date-desc')).toContain('No plans found');
-  });
-
-  test('shows filter-specific message when empty', () => {
-    expect(formatPlanList([], 'done', 'date-desc')).toContain('No plans with status "done"');
-  });
-
-  test('includes plan details in output', () => {
-    const plans = [makePlanItem({ name: 'alpha', title: 'Alpha Plan', totalTasks: 5, doneTasks: 3 })];
-    const output = formatPlanList(plans, 'all', 'date-desc');
-    expect(output).toContain('alpha');
-    expect(output).toContain('Alpha Plan');
-    expect(output).toContain('3/5 tasks');
-  });
-
-  test('shows header with count and sort', () => {
-    const plans = [makePlanItem({ name: 'a' }), makePlanItem({ name: 'b' })];
-    const output = formatPlanList(plans, 'all', 'tasks');
-    expect(output).toContain('All plans (2)');
-    expect(output).toContain('most tasks first');
-  });
-});
-
-// ── parseArgs ────────────────────────────────────────────────────────────────
-
-describe('parseArgs', () => {
-  test('parses filter only', () => {
-    expect(parseArgs('done')).toEqual({ filter: 'done', sort: 'date-desc' });
-  });
-
-  test('parses sort only', () => {
-    expect(parseArgs('oldest')).toEqual({ filter: 'all', sort: 'date-asc' });
-  });
-
-  test('parses filter and sort together', () => {
-    expect(parseArgs('in-progress tasks')).toEqual({ filter: 'in-progress', sort: 'tasks' });
-  });
-
-  test('accepts aliases', () => {
-    expect(parseArgs('pending newest')).toEqual({ filter: 'in-progress', sort: 'date-desc' });
-    expect(parseArgs('active oldest')).toEqual({ filter: 'in-progress', sort: 'date-asc' });
-    expect(parseArgs('completed name')).toEqual({ filter: 'done', sort: 'name' });
-  });
-
-  test('defaults to all + date-desc for unknown tokens', () => {
-    expect(parseArgs('unknown gibberish')).toEqual({ filter: 'all', sort: 'date-desc' });
-  });
-
-  test('is case-insensitive', () => {
-    expect(parseArgs('DONE TASKS')).toEqual({ filter: 'done', sort: 'tasks' });
-  });
-});
-
-// ── loadPlanListItems (integration) ──────────────────────────────────────────
-
-describe('loadPlanListItems', () => {
-  test('returns empty for no plans', async () => {
-    const items = await runPlanIO(loadPlanListItems());
-    expect(items).toEqual([]);
-  });
-
-  test('loads plans with task counts', async () => {
-    await runPlanIO(upsertPlanEntry('alpha', { status: 'in-progress', title: 'Alpha' }));
-    await runPlanIO(
-      writeTasksJsonl('.plans/alpha', meta('alpha'), [
-        task('t-001', 'done'),
-        task('t-002', 'pending'),
-        task('t-003', 'pending'),
-      ]),
-    );
-
-    const items = await runPlanIO(loadPlanListItems());
-    expect(items).toHaveLength(1);
-    expect(items[0].name).toBe('alpha');
-    expect(items[0].totalTasks).toBe(3);
-    expect(items[0].doneTasks).toBe(1);
-    expect(items[0].pendingTasks).toBe(2);
-  });
-
-  test('handles plans without task files', async () => {
-    await runPlanIO(upsertPlanEntry('orphan', { status: 'in-progress', title: 'Orphan' }));
-
-    const items = await runPlanIO(loadPlanListItems());
-    expect(items).toHaveLength(1);
-    expect(items[0].totalTasks).toBe(0);
-    expect(items[0].doneTasks).toBe(0);
-  });
-
-  test('loads multiple plans', async () => {
-    await runPlanIO(upsertPlanEntry('alpha', { status: 'in-progress', title: 'Alpha' }));
-    await runPlanIO(upsertPlanEntry('beta', { status: 'done', title: 'Beta' }));
-    await runPlanIO(
-      writeTasksJsonl('.plans/alpha', meta('alpha'), [task('t-001', 'pending')]),
-    );
-    await runPlanIO(
-      writeTasksJsonl('.plans/beta', meta('beta'), [task('t-001', 'done'), task('t-002', 'done')]),
-    );
-
-    const items = await runPlanIO(loadPlanListItems());
-    expect(items).toHaveLength(2);
-
-    const alpha = items.find((i) => i.name === 'alpha')!;
-    expect(alpha.status).toBe('in-progress');
-    expect(alpha.totalTasks).toBe(1);
-
-    const beta = items.find((i) => i.name === 'beta')!;
-    expect(beta.status).toBe('done');
-    expect(beta.totalTasks).toBe(2);
-    expect(beta.doneTasks).toBe(2);
-  });
-});

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

@@ -1,57 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { Effect } from 'effect';
-import { chdir } from 'node:process';
-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 {
-  loadHandoff,
-  readAndClearExecPending,
-  saveHandoff,
-  writeExecPending,
-} from '../storage/plan-storage.js';
-import type { ExecPendingConfig } from '../types.js';
-
-const run = <A, E>(program: Effect.Effect<A, E, FileSystem>): Promise<A> =>
-  Effect.runPromise(program.pipe(Effect.provideService(FileSystem, nodeFileSystemService)));
-
-const originalCwd = process.cwd();
-let dir: string;
-const config: ExecPendingConfig = { model: { provider: 'anthropic', id: 'opus' }, thinking: 'low' };
-
-beforeEach(async () => {
-  dir = await mkdtemp(join(tmpdir(), 'plan-mode-plan-'));
-  chdir(dir);
-});
-afterEach(async () => {
-  chdir(originalCwd);
-  await rm(dir, { recursive: true, force: true });
-});
-
-describe('handoff documents', () => {
-  test('round trips handoff content', async () => {
-    await run(saveHandoff('.plans/p', '# Handoff'));
-    await expect(run(loadHandoff('.plans/p'))).resolves.toBe('# Handoff');
-  });
-
-  test('missing handoff returns undefined', async () => {
-    await expect(run(loadHandoff('.plans/missing'))).resolves.toBeUndefined();
-  });
-});
-
-describe('exec-pending markers', () => {
-  test('writes, reads, and clears a marker', async () => {
-    await run(writeExecPending('.plans/p', config));
-    const first = await run(readAndClearExecPending());
-    expect(first?.planDir).toBe('.plans/p');
-    expect(first?.config).toEqual(config);
-
-    // Marker is cleared after reading.
-    await expect(run(readAndClearExecPending())).resolves.toBeUndefined();
-  });
-
-  test('returns undefined when .plans does not exist', async () => {
-    await expect(run(readAndClearExecPending())).resolves.toBeUndefined();
-  });
-});

package/extensions/plan-mode/__tests__/plans-manifest.test.ts

@@ -1,120 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { Effect } from 'effect';
-import { chdir } from 'node:process';
-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 {
-  readPlansManifest,
-  reconcilePlanStatus,
-  upsertPlanEntry,
-  writePlansManifest,
-} from '../storage/plans-manifest.js';
-
-const run = <A, E>(program: Effect.Effect<A, E, FileSystem>): Promise<A> =>
-  Effect.runPromise(program.pipe(Effect.provideService(FileSystem, nodeFileSystemService)));
-
-const originalCwd = process.cwd();
-let dir: string;
-
-beforeEach(async () => {
-  dir = await mkdtemp(join(tmpdir(), 'plan-mode-manifest-'));
-  chdir(dir);
-});
-afterEach(async () => {
-  chdir(originalCwd);
-  await rm(dir, { recursive: true, force: true });
-});
-
-describe('plans.jsonl manifest', () => {
-  test('round trips entries', async () => {
-    const entry = {
-      _type: 'plan' as const,
-      name: 'refactor',
-      status: 'in-progress' as const,
-      title: 'Refactor',
-      created_at: 'now',
-      completed_at: null,
-    };
-    await run(writePlansManifest([entry]));
-    await expect(run(readPlansManifest())).resolves.toEqual([entry]);
-  });
-
-  test('missing manifest returns an empty list', async () => {
-    await expect(run(readPlansManifest())).resolves.toEqual([]);
-  });
-
-  test('upserts new entries', async () => {
-    await run(upsertPlanEntry('new-plan', { status: 'in-progress', title: 'New Plan' }));
-    const entries = await run(readPlansManifest());
-    expect(entries).toHaveLength(1);
-    expect(entries[0]?.name).toBe('new-plan');
-    expect(entries[0]?.title).toBe('New Plan');
-  });
-
-  test('upserts existing entries without changing created_at', async () => {
-    await run(
-      writePlansManifest([
-        {
-          _type: 'plan',
-          name: 'p',
-          status: 'in-progress',
-          title: 'Old',
-          created_at: 'created',
-          completed_at: null,
-        },
-      ]),
-    );
-    await run(upsertPlanEntry('p', { status: 'done', title: 'New' }));
-    const [entry] = await run(readPlansManifest());
-    expect(entry.created_at).toBe('created');
-    expect(entry.status).toBe('done');
-    expect(entry.completed_at).toBeString();
-  });
-
-  test('records a reason for terminal statuses and clears completed_at on reopen', async () => {
-    await run(upsertPlanEntry('p', { status: 'in-progress', title: 'P' }));
-    await run(upsertPlanEntry('p', { status: 'superseded', reason: 'absorbed by q' }));
-    let [entry] = await run(readPlansManifest());
-    expect(entry.status).toBe('superseded');
-    expect(entry.reason).toBe('absorbed by q');
-    expect(entry.completed_at).toBeString();
-
-    // Reopening clears completed_at.
-    await run(upsertPlanEntry('p', { status: 'in-progress' }));
-    [entry] = await run(readPlansManifest());
-    expect(entry.status).toBe('in-progress');
-    expect(entry.completed_at).toBeNull();
-  });
-});
-
-describe('reconcilePlanStatus (registry as a projection of task state)', () => {
-  test('flips in-progress → done when finalizable', async () => {
-    await run(upsertPlanEntry('p', { status: 'in-progress', title: 'P' }));
-    await run(reconcilePlanStatus('p', true, 'P'));
-    const [entry] = await run(readPlansManifest());
-    expect(entry.status).toBe('done');
-  });
-
-  test('reopens done → in-progress when no longer finalizable', async () => {
-    await run(upsertPlanEntry('p', { status: 'done', title: 'P' }));
-    await run(reconcilePlanStatus('p', false, 'P'));
-    const [entry] = await run(readPlansManifest());
-    expect(entry.status).toBe('in-progress');
-    expect(entry.completed_at).toBeNull();
-  });
-
-  test('never overrides a manually-closed terminal status', async () => {
-    await run(upsertPlanEntry('p', { status: 'abandoned', title: 'P', reason: 'rejected' }));
-    await run(reconcilePlanStatus('p', true, 'P'));
-    const [entry] = await run(readPlansManifest());
-    expect(entry.status).toBe('abandoned');
-    expect(entry.reason).toBe('rejected');
-  });
-
-  test('is a no-op for an unknown plan (nothing created)', async () => {
-    await run(reconcilePlanStatus('ghost', true));
-    await expect(run(readPlansManifest())).resolves.toEqual([]);
-  });
-});