@dreki-gg/pi-plan-mode 0.21.0 → 0.24.0

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

@@ -0,0 +1,97 @@
+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 { readPlansManifest } from '../storage/plans-manifest.js';
+import {
+  readInitiativesManifest,
+  upsertInitiativeEntry,
+} from '../storage/initiatives-manifest.js';
+import { registerSubmitPlanTool } from '../tools/submit-plan.js';
+
+const runPlanIO = makePlanRuntime();
+
+interface SubmitParams {
+  name: string;
+  title: string;
+  handoff: string;
+  tasks: Array<{ id: string; description: string }>;
+  initiative?: string;
+  depends_on_plans?: string[];
+}
+interface CapturedTool {
+  execute: (
+    id: string,
+    params: SubmitParams,
+  ) => Promise<{ content?: Array<{ text: string }>; details?: unknown }>;
+}
+
+function setup(): CapturedTool {
+  let tool: CapturedTool | undefined;
+  const pi = {
+    registerTool: (config: CapturedTool) => {
+      tool = config;
+    },
+  } as unknown as Parameters<typeof registerSubmitPlanTool>[0];
+  registerSubmitPlanTool(pi, runPlanIO, { onPlanSubmitted: () => {} });
+  return tool!;
+}
+
+const baseParams = (over: Partial<SubmitParams> = {}): SubmitParams => ({
+  name: 'auth-jwt',
+  title: 'Auth JWT',
+  handoff: '# handoff',
+  tasks: [{ id: 't-001', description: 'do it' }],
+  ...over,
+});
+
+const originalCwd = process.cwd();
+let dir: string;
+beforeEach(async () => {
+  dir = await mkdtemp(join(tmpdir(), 'plan-mode-submit-plan-'));
+  chdir(dir);
+});
+afterEach(async () => {
+  chdir(originalCwd);
+  await rm(dir, { recursive: true, force: true });
+});
+
+describe('submit_plan tool — initiative + plan deps', () => {
+  test('persists initiative + depends_on onto the plan manifest entry', async () => {
+    await runPlanIO(upsertInitiativeEntry('auth-overhaul', { status: 'in-progress', title: 'Auth' }));
+    const tool = setup();
+    await tool.execute('c', baseParams({ initiative: 'auth-overhaul', depends_on_plans: ['auth-schema'] }));
+
+    const [entry] = await runPlanIO(readPlansManifest());
+    expect(entry.initiative).toBe('auth-overhaul');
+    expect(entry.depends_on).toEqual(['auth-schema']);
+  });
+
+  test('kebab-cases the initiative name and reconciles it (member keeps it in-progress)', async () => {
+    await runPlanIO(upsertInitiativeEntry('auth-overhaul', { status: 'done', title: 'Auth' }));
+    const tool = setup();
+    await tool.execute('c', baseParams({ initiative: 'Auth Overhaul' }));
+
+    const [plan] = await runPlanIO(readPlansManifest());
+    expect(plan.initiative).toBe('auth-overhaul');
+    // A fresh in-progress member must reopen a prematurely-done initiative.
+    const [init] = await runPlanIO(readInitiativesManifest());
+    expect(init.status).toBe('in-progress');
+  });
+
+  test('warns softly when the initiative has no registry entry yet', async () => {
+    const tool = setup();
+    const result = await tool.execute('c', baseParams({ initiative: 'ghost-initiative' }));
+    expect(result.content?.[0]?.text).toMatch(/no initiatives\.jsonl entry yet/);
+  });
+
+  test('a standalone plan stores no initiative and no warning', async () => {
+    const tool = setup();
+    const result = await tool.execute('c', baseParams());
+    const [entry] = await runPlanIO(readPlansManifest());
+    expect(entry.initiative).toBeUndefined();
+    expect(result.content?.[0]?.text).not.toMatch(/initiative/i);
+  });
+});

package/extensions/plan-mode/__tests__/update-initiative.test.ts

@@ -0,0 +1,72 @@
+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 {
+  readInitiativesManifest,
+  upsertInitiativeEntry,
+} from '../storage/initiatives-manifest.js';
+import { registerUpdateInitiativeTool } from '../tools/update-initiative.js';
+
+const runPlanIO = makePlanRuntime();
+
+interface CapturedTool {
+  execute: (
+    id: string,
+    params: { initiative: string; status: string; reason?: string },
+  ) => Promise<{ content?: Array<{ text: string }>; details?: unknown }>;
+}
+
+function setup(): CapturedTool {
+  let tool: CapturedTool | undefined;
+  const pi = {
+    registerTool: (config: CapturedTool) => {
+      tool = config;
+    },
+  } as unknown as Parameters<typeof registerUpdateInitiativeTool>[0];
+  registerUpdateInitiativeTool(pi, runPlanIO);
+  return tool!;
+}
+
+const originalCwd = process.cwd();
+let dir: string;
+beforeEach(async () => {
+  dir = await mkdtemp(join(tmpdir(), 'plan-mode-update-init-'));
+  chdir(dir);
+});
+afterEach(async () => {
+  chdir(originalCwd);
+  await rm(dir, { recursive: true, force: true });
+});
+
+describe('update_initiative tool', () => {
+  test('closes an initiative as superseded with a reason', async () => {
+    await runPlanIO(upsertInitiativeEntry('big', { status: 'in-progress', title: 'Big' }));
+    const tool = setup();
+    const result = await tool.execute('c', {
+      initiative: 'big',
+      status: 'superseded',
+      reason: 'merged into mega',
+    });
+    expect(result.content?.[0]?.text).toMatch(/in-progress → superseded/);
+    const [entry] = await runPlanIO(readInitiativesManifest());
+    expect(entry.status).toBe('superseded');
+    expect(entry.reason).toBe('merged into mega');
+  });
+
+  test('accepts a .plans/<name> hint', async () => {
+    await runPlanIO(upsertInitiativeEntry('big', { status: 'in-progress', title: 'Big' }));
+    const tool = setup();
+    await tool.execute('c', { initiative: '.plans/big', status: 'abandoned', reason: 'dropped' });
+    const [entry] = await runPlanIO(readInitiativesManifest());
+    expect(entry.status).toBe('abandoned');
+  });
+
+  test('reports not_found for an unknown initiative (no throw)', async () => {
+    const tool = setup();
+    const result = await tool.execute('c', { initiative: 'ghost', status: 'done' });
+    expect((result.details as { error?: string }).error).toBe('not_found');
+  });
+});

package/extensions/plan-mode/commands/list-initiatives.ts

@@ -0,0 +1,148 @@
+/**
+ * /initiatives command — list, filter, and sort initiatives interactively.
+ *
+ * The initiative sibling of /plans. Reads the initiatives registry plus the
+ * plans manifest to roll up member-plan progress (done/total, ready/blocked).
+ */
+
+import { Effect } from 'effect';
+import type { ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
+import type { RunPlanIO } from '../effects/runtime.js';
+import { FileSystem } from '../effects/filesystem.js';
+import { readPlansManifest, type PlanManifestEntry } from '../storage/plans-manifest.js';
+import {
+  readInitiativesManifest,
+  type InitiativeManifestEntry,
+} from '../storage/initiatives-manifest.js';
+import { initiativeRollup } from '../initiative.js';
+import type { InitiativeStatus } from '../types.js';
+
+export type StatusFilter = 'all' | InitiativeStatus;
+
+export interface InitiativeListItem {
+  name: string;
+  title: string;
+  status: InitiativeStatus;
+  created_at: string;
+  totalPlans: number;
+  donePlans: number;
+  ready: number;
+  blocked: number;
+}
+
+export function filterInitiatives(
+  items: InitiativeListItem[],
+  filter: StatusFilter,
+): InitiativeListItem[] {
+  if (filter === 'all') return items;
+  return items.filter((i) => i.status === filter);
+}
+
+const STATUS_ICON: Record<InitiativeStatus, string> = {
+  'in-progress': '🔵',
+  done: '✅',
+  superseded: '🔄',
+  abandoned: '❌',
+};
+
+export function formatInitiativeList(items: InitiativeListItem[], filter: StatusFilter): string {
+  if (items.length === 0) {
+    return filter === 'all'
+      ? 'No initiatives found in .plans/initiatives.jsonl'
+      : `No initiatives with status "${filter}"`;
+  }
+  const header =
+    filter === 'all'
+      ? `All initiatives (${items.length})`
+      : `Initiatives: ${filter} (${items.length})`;
+  const lines = items.map((i) => {
+    const icon = STATUS_ICON[i.status];
+    const progress =
+      i.totalPlans > 0
+        ? ` [${i.donePlans}/${i.totalPlans} plans, ready ${i.ready}, blocked ${i.blocked}]`
+        : ' [no plans]';
+    const date = i.created_at.slice(0, 10);
+    return `  ${icon} ${i.name} — ${i.title}${progress}  (${date})`;
+  });
+  return `${header}\n${lines.join('\n')}`;
+}
+
+export function loadInitiativeListItems(): Effect.Effect<InitiativeListItem[], never, FileSystem> {
+  return Effect.gen(function* () {
+    const initiatives = yield* Effect.orElseSucceed(
+      readInitiativesManifest(),
+      () => [] as InitiativeManifestEntry[],
+    );
+    const plans = yield* Effect.orElseSucceed(
+      readPlansManifest(),
+      () => [] as PlanManifestEntry[],
+    );
+    return initiatives.map((entry): InitiativeListItem => {
+      const r = initiativeRollup(entry.name, plans);
+      return {
+        name: entry.name,
+        title: entry.title,
+        status: entry.status,
+        created_at: entry.created_at,
+        totalPlans: r.total,
+        donePlans: r.done,
+        ready: r.ready,
+        blocked: r.blocked,
+      };
+    });
+  });
+}
+
+const FILTER_ALIASES: Record<string, StatusFilter> = {
+  all: 'all',
+  'in-progress': 'in-progress',
+  active: 'in-progress',
+  done: 'done',
+  completed: 'done',
+  superseded: 'superseded',
+  abandoned: 'abandoned',
+};
+
+export function parseFilter(raw: string): StatusFilter {
+  for (const token of raw.toLowerCase().split(/\s+/)) {
+    if (FILTER_ALIASES[token]) return FILTER_ALIASES[token];
+  }
+  return 'all';
+}
+
+export async function handleListInitiatives(
+  ctx: ExtensionCommandContext,
+  runPlanIO: RunPlanIO,
+  args?: string,
+): Promise<void> {
+  const items = await runPlanIO(loadInitiativeListItems());
+  if (items.length === 0) {
+    ctx.ui.notify('No initiatives found in .plans/initiatives.jsonl', 'info');
+    return;
+  }
+
+  let filter: StatusFilter = 'all';
+  if (args?.trim()) {
+    filter = parseFilter(args.trim());
+  } else {
+    const choice = await ctx.ui.select('Filter initiatives by status:', [
+      'All',
+      'In-progress',
+      'Done',
+      'Superseded',
+      'Abandoned',
+    ]);
+    if (!choice) return;
+    const map: Record<string, StatusFilter> = {
+      All: 'all',
+      'In-progress': 'in-progress',
+      Done: 'done',
+      Superseded: 'superseded',
+      Abandoned: 'abandoned',
+    };
+    filter = map[choice] ?? 'all';
+  }
+
+  const filtered = filterInitiatives(items, filter);
+  ctx.ui.notify(formatInitiativeList(filtered, filter), 'info');
+}

package/extensions/plan-mode/commands/list-plans.ts

@@ -0,0 +1,229 @@
+/**
+ * /plans command — list, filter, and sort plans interactively.
+ *
+ * Reads from the plans manifest AND task snapshots to build a rich table
+ * with status, task counts, and dates. The user can filter by status and
+ * sort by different criteria via interactive selectors.
+ */
+
+import { Effect } from 'effect';
+import type { ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
+import type { RunPlanIO } from '../effects/runtime.js';
+import { FileSystem } from '../effects/filesystem.js';
+import { readPlansManifest, type PlanManifestEntry } from '../storage/plans-manifest.js';
+import { readTasksJsonl } from '../storage/task-storage.js';
+import type { PlanStatus } from '../types.js';
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export type SortField = 'name' | 'date-asc' | 'date-desc' | 'tasks';
+export type StatusFilter = 'all' | PlanStatus;
+
+export interface PlanListItem {
+  name: string;
+  title: string;
+  status: PlanStatus;
+  created_at: string;
+  completed_at: string | null;
+  totalTasks: number;
+  doneTasks: number;
+  pendingTasks: number;
+}
+
+// ── Core logic (pure, testable) ──────────────────────────────────────────────
+
+export function filterPlans(plans: PlanListItem[], filter: StatusFilter): PlanListItem[] {
+  if (filter === 'all') return plans;
+  return plans.filter((p) => p.status === filter);
+}
+
+export function sortPlans(plans: PlanListItem[], sort: SortField): PlanListItem[] {
+  const sorted = [...plans];
+  switch (sort) {
+    case 'name':
+      sorted.sort((a, b) => a.name.localeCompare(b.name));
+      break;
+    case 'date-asc':
+      sorted.sort((a, b) => a.created_at.localeCompare(b.created_at));
+      break;
+    case 'date-desc':
+      sorted.sort((a, b) => b.created_at.localeCompare(a.created_at));
+      break;
+    case 'tasks':
+      sorted.sort((a, b) => b.totalTasks - a.totalTasks);
+      break;
+  }
+  return sorted;
+}
+
+const STATUS_ICON: Record<PlanStatus, string> = {
+  'in-progress': '🔵',
+  done: '✅',
+  superseded: '🔄',
+  abandoned: '❌',
+};
+
+export function formatPlanList(plans: PlanListItem[], filter: StatusFilter, sort: SortField): string {
+  if (plans.length === 0) {
+    return filter === 'all'
+      ? 'No plans found in .plans/plans.jsonl'
+      : `No plans with status "${filter}"`;
+  }
+
+  const sortLabel: Record<SortField, string> = {
+    name: 'name',
+    'date-asc': 'oldest first',
+    'date-desc': 'newest first',
+    tasks: 'most tasks first',
+  };
+
+  const header =
+    filter === 'all'
+      ? `All plans (${plans.length}) — sorted by ${sortLabel[sort]}`
+      : `Plans: ${filter} (${plans.length}) — sorted by ${sortLabel[sort]}`;
+
+  const lines = plans.map((p) => {
+    const icon = STATUS_ICON[p.status];
+    const progress =
+      p.totalTasks > 0 ? ` [${p.doneTasks}/${p.totalTasks} tasks]` : ' [no tasks]';
+    const date = p.created_at.slice(0, 10);
+    return `  ${icon} ${p.name} — ${p.title}${progress}  (${date})`;
+  });
+
+  return `${header}\n${lines.join('\n')}`;
+}
+
+// ── Data loading (Effect-based) ──────────────────────────────────────────────
+
+export function loadPlanListItems(): Effect.Effect<PlanListItem[], never, FileSystem> {
+  return Effect.gen(function* () {
+    const manifest = yield* Effect.orElseSucceed(readPlansManifest(), () => [] as PlanManifestEntry[]);
+    const items: PlanListItem[] = [];
+
+    for (const entry of manifest) {
+      const dir = `.plans/${entry.name}`;
+      const snapshot = yield* Effect.orElseSucceed(readTasksJsonl(dir), () => undefined);
+      const totalTasks = snapshot?.tasks.length ?? 0;
+      const doneTasks = snapshot?.tasks.filter(
+        (t) => t.status === 'done' || t.status === 'skipped',
+      ).length ?? 0;
+      const pendingTasks = snapshot?.tasks.filter((t) => t.status === 'pending').length ?? 0;
+
+      items.push({
+        name: entry.name,
+        title: entry.title,
+        status: entry.status,
+        created_at: entry.created_at,
+        completed_at: entry.completed_at,
+        totalTasks,
+        doneTasks,
+        pendingTasks,
+      });
+    }
+
+    return items;
+  });
+}
+
+// ── Interactive command handler ──────────────────────────────────────────────
+
+export async function handleListPlans(
+  ctx: ExtensionCommandContext,
+  runPlanIO: RunPlanIO,
+  args?: string,
+): Promise<void> {
+  const allItems = await runPlanIO(loadPlanListItems());
+
+  if (allItems.length === 0) {
+    ctx.ui.notify('No plans found in .plans/plans.jsonl', 'info');
+    return;
+  }
+
+  // Parse inline args: /plans [filter] [sort]
+  // e.g. /plans done tasks, /plans in-progress date-asc
+  let filter: StatusFilter = 'all';
+  let sort: SortField = 'date-desc';
+
+  if (args?.trim()) {
+    const parsed = parseArgs(args.trim());
+    filter = parsed.filter;
+    sort = parsed.sort;
+  } else {
+    // Interactive mode: ask the user
+    const filterChoice = await ctx.ui.select('Filter plans by status:', [
+      'All',
+      'In-progress',
+      'Done',
+      'Superseded',
+      'Abandoned',
+    ]);
+    if (!filterChoice) return;
+
+    const filterMap: Record<string, StatusFilter> = {
+      All: 'all',
+      'In-progress': 'in-progress',
+      Done: 'done',
+      Superseded: 'superseded',
+      Abandoned: 'abandoned',
+    };
+    filter = filterMap[filterChoice] ?? 'all';
+
+    const sortChoice = await ctx.ui.select('Sort by:', [
+      'Newest first',
+      'Oldest first',
+      'Most tasks',
+      'Name',
+    ]);
+    if (!sortChoice) return;
+
+    const sortMap: Record<string, SortField> = {
+      'Newest first': 'date-desc',
+      'Oldest first': 'date-asc',
+      'Most tasks': 'tasks',
+      Name: 'name',
+    };
+    sort = sortMap[sortChoice] ?? 'date-desc';
+  }
+
+  const filtered = filterPlans(allItems, filter);
+  const sorted = sortPlans(filtered, sort);
+  const output = formatPlanList(sorted, filter, sort);
+
+  ctx.ui.notify(output, 'info');
+}
+
+// ── Arg parsing ──────────────────────────────────────────────────────────────
+
+const FILTER_ALIASES: Record<string, StatusFilter> = {
+  all: 'all',
+  'in-progress': 'in-progress',
+  pending: 'in-progress',
+  active: 'in-progress',
+  done: 'done',
+  completed: 'done',
+  superseded: 'superseded',
+  abandoned: 'abandoned',
+};
+
+const SORT_ALIASES: Record<string, SortField> = {
+  name: 'name',
+  'date-asc': 'date-asc',
+  oldest: 'date-asc',
+  'date-desc': 'date-desc',
+  newest: 'date-desc',
+  tasks: 'tasks',
+  'task-count': 'tasks',
+};
+
+export function parseArgs(raw: string): { filter: StatusFilter; sort: SortField } {
+  const tokens = raw.toLowerCase().split(/\s+/);
+  let filter: StatusFilter = 'all';
+  let sort: SortField = 'date-desc';
+
+  for (const token of tokens) {
+    if (FILTER_ALIASES[token]) filter = FILTER_ALIASES[token];
+    else if (SORT_ALIASES[token]) sort = SORT_ALIASES[token];
+  }
+
+  return { filter, sort };
+}

package/extensions/plan-mode/constants.ts

@@ -10,6 +10,7 @@ export const PLAN_TOOLS = [
   'find',
   'ls',
   'submit_plan',
+  'submit_initiative',
   'revise_plan',
   'preview_prototype',
   'write',
@@ -19,6 +20,8 @@ export const PLAN_TOOLS = [
   'plan_status',
   'set_active_plan',
   'update_plan',
+  'update_initiative',
+  'initiative_status',
   'reconcile_plans',
 ];
 
@@ -33,6 +36,8 @@ export const EXEC_TOOLS = [
   'plan_status',
   'set_active_plan',
   'update_plan',
+  'update_initiative',
+  'initiative_status',
   'reconcile_plans',
 ];
 

package/extensions/plan-mode/html/render.ts

@@ -1,24 +1,47 @@
-import { readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import pug from 'pug';
+/**
+ * Prototype document builder.
+ *
+ * A prototype is a planning-phase visual aid the agent authors freely — there
+ * is no template engine and no imposed theme. Whatever HTML the agent (or a
+ * delegated ux-designer subagent) writes is what the user sees.
+ *
+ * The only thing this does is tolerate a bare fragment: if the agent passes
+ * body-only markup instead of a complete page, we drop it into a minimal,
+ * UNSTYLED shell so the browser still renders it. No fonts, colors, or layout
+ * are injected — the design is entirely the agent's.
+ */
+
+function escapeHtml(value: string): string {
+  return value
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
 
-const templatePath = join(dirname(fileURLToPath(import.meta.url)), 'templates', 'prototype.pug');
+/** True when the markup is already a complete HTML page. */
+function isFullDocument(markup: string): boolean {
+  return /<!doctype\s+html|<html[\s>]/i.test(markup);
+}
 
 /**
- * Renders a standalone prototype preview: a minimal header (title + one-line
- * intent) wrapping the rendered Pug body. This is a planning-phase visual aid,
- * not a plan dump — no tasks, no handoff.
+ * Returns a standalone HTML document for the prototype. Full documents are
+ * passed through verbatim; fragments are wrapped in a barebones shell.
  */
-export function renderPrototypeHtml(title: string, intent: string, pugBody: string): string {
-  const template = readFileSync(templatePath, 'utf8');
-  const prototypeHtml = pugBody.trim() ? pug.render(pugBody) : '';
+export function buildPrototypeDocument(title: string, html: string): string {
+  const markup = html.trim();
+
+  if (isFullDocument(markup)) return markup;
 
-  return pug.render(template, {
-    filename: templatePath,
-    title,
-    intent,
-    prototypeHtml,
-    generatedAt: new Date().toISOString(),
-  });
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml(title)}</title>
+</head>
+<body>
+${markup}
+</body>
+</html>`;
 }