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

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

@@ -1,174 +0,0 @@
-import { Effect, Either, Option } from 'effect';
-import { FileSystem } from '../effects/filesystem.js';
-import { JsonlParseError, JsonlValidationError, PlanWriteError } from '../errors.js';
-import { decodePlanManifestEntry } from '../schema.js';
-import type { PlanStatus } from '../types.js';
-import { withFileLock } from './file-lock.js';
-
-const MANIFEST_DIR = '.plans';
-const MANIFEST_PATH = '.plans/plans.jsonl';
-
-export interface PlanManifestEntry {
-  _type: 'plan';
-  name: string;
-  status: PlanStatus;
-  title: string;
-  created_at: string;
-  completed_at: string | null;
-  reason?: string;
-  /** Parent initiative name (kebab). Absent = standalone flat plan. */
-  initiative?: string;
-  /** Plan-level dependencies (plan names). Cross-initiative allowed. */
-  depends_on?: string[];
-}
-
-/** A status is terminal (closed) when it is anything other than in-progress. */
-export function isTerminalStatus(status: PlanStatus): boolean {
-  return status !== 'in-progress';
-}
-
-type ReadError = JsonlParseError | JsonlValidationError;
-
-export function readPlansManifest(): Effect.Effect<PlanManifestEntry[], ReadError, FileSystem> {
-  return Effect.gen(function* () {
-    const fs = yield* FileSystem;
-    // A missing or unreadable manifest is treated as "no plans".
-    const maybeText = yield* Effect.option(fs.readFileString(MANIFEST_PATH));
-    if (Option.isNone(maybeText)) return [];
-
-    const entries: PlanManifestEntry[] = [];
-    for (const [index, raw] of maybeText.value.split(/\r?\n/).entries()) {
-      if (!raw.trim()) continue;
-      const line = index + 1;
-
-      let parsed: unknown;
-      try {
-        parsed = JSON.parse(raw);
-      } catch (cause) {
-        return yield* Effect.fail(new JsonlParseError({ path: MANIFEST_PATH, line, cause }));
-      }
-
-      const decoded = decodePlanManifestEntry(parsed);
-      if (Either.isLeft(decoded)) {
-        return yield* Effect.fail(
-          new JsonlValidationError({ path: MANIFEST_PATH, line, reason: decoded.left.message }),
-        );
-      }
-      entries.push(decoded.right);
-    }
-    return entries;
-  });
-}
-
-export function writePlansManifest(
-  entries: PlanManifestEntry[],
-): Effect.Effect<void, PlanWriteError, FileSystem> {
-  return Effect.gen(function* () {
-    const fs = yield* FileSystem;
-    yield* fs.makeDir(MANIFEST_DIR);
-    const content =
-      entries.map((entry) => JSON.stringify(entry)).join('\n') + (entries.length ? '\n' : '');
-    yield* fs.writeFileAtomic(MANIFEST_PATH, content);
-  });
-}
-
-export interface PlanUpsert {
-  status: PlanStatus;
-  title?: string;
-  reason?: string;
-  /** Parent initiative name; preserved when omitted. */
-  initiative?: string;
-  /** Plan-level dependencies (plan names); preserved when omitted. */
-  depends_on?: string[];
-}
-
-/**
- * Pure transform: upsert `name` into the in-memory `entries` array, preserving
- * created_at / membership / deps from any existing entry. No IO — shared by the
- * locked `upsertPlanEntry` and `reconcilePlanStatus` so both flow through one
- * serialized read-modify-write and never nest locks.
- */
-export function applyPlanUpsert(
-  entries: PlanManifestEntry[],
-  name: string,
-  updates: PlanUpsert,
-): void {
-  const now = new Date().toISOString();
-  const index = entries.findIndex((entry) => entry.name === name);
-  const existing = index === -1 ? undefined : entries[index];
-  const entry: PlanManifestEntry = {
-    _type: 'plan',
-    name,
-    status: updates.status,
-    title: updates.title ?? existing?.title ?? 'Untitled plan',
-    created_at: existing?.created_at ?? now,
-    // Terminal statuses record a completion timestamp; reopening clears it.
-    completed_at: isTerminalStatus(updates.status) ? (existing?.completed_at ?? now) : null,
-    reason: updates.reason ?? existing?.reason,
-    // Membership + plan-level deps are preserved across status-only upserts.
-    initiative: updates.initiative ?? existing?.initiative,
-    depends_on: updates.depends_on ?? existing?.depends_on,
-  };
-  if (index === -1) entries.push(entry);
-  else entries[index] = entry;
-}
-
-/**
- * Serialized read-modify-write of the plans registry. Holds a process-wide lock
- * on the manifest path across the whole read → transform → write so concurrent
- * tool calls cannot clobber each other (lost-update race). `transform` mutates
- * the entries array in place and returns `true` when it changed something
- * (return `false` to skip the rewrite).
- */
-export function mutatePlansManifest(
-  transform: (entries: PlanManifestEntry[]) => boolean,
-): Effect.Effect<void, ReadError | PlanWriteError, FileSystem> {
-  return withFileLock(
-    MANIFEST_PATH,
-    Effect.gen(function* () {
-      const entries = yield* readPlansManifest();
-      const changed = transform(entries);
-      if (changed) yield* writePlansManifest(entries);
-    }),
-  );
-}
-
-export function upsertPlanEntry(
-  name: string,
-  updates: PlanUpsert,
-): Effect.Effect<void, ReadError | PlanWriteError, FileSystem> {
-  return mutatePlansManifest((entries) => {
-    applyPlanUpsert(entries, name, updates);
-    return true;
-  });
-}
-
-/**
- * Reconcile a plan's registry status from its task state.
- *
- * The registry `status` is a PROJECTION of task state, not a parallel flag.
- * Call this wherever tasks are written so completion is never coupled to a
- * formal in-session execution run (see FEEDBACK #1). `finalizable` means every
- * active task is resolved AND no deferred follow-ups remain.
- *
- * Guard: a manually-set terminal status (`superseded` / `abandoned`) is never
- * auto-overridden — only `in-progress` ⇄ `done` is derived from tasks.
- */
-export function reconcilePlanStatus(
-  name: string,
-  finalizable: boolean,
-  title?: string,
-): Effect.Effect<void, ReadError | PlanWriteError, FileSystem> {
-  return mutatePlansManifest((entries) => {
-    const existing = entries.find((entry) => entry.name === name);
-    // Reconcile only reflects task state for KNOWN plans; never conjure an
-    // entry for an unregistered plan (orphans are surfaced, not auto-created).
-    if (!existing) return false;
-    // Do not resurrect / clobber an explicitly closed plan.
-    if (existing.status === 'superseded' || existing.status === 'abandoned') return false;
-    const status: PlanStatus = finalizable ? 'done' : 'in-progress';
-    if (existing.status === status) return false; // no change
-    applyPlanUpsert(entries, name, { status, title });
-    return true;
-  });
-}

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

@@ -1,111 +0,0 @@
-import { Effect, Either, Option } from 'effect';
-import { join } from 'node:path';
-import { FileSystem } from '../effects/filesystem.js';
-import {
-  JsonlParseError,
-  JsonlValidationError,
-  MissingMetaRecord,
-  PlanWriteError,
-  TaskNotFound,
-  TasksFileNotFound,
-} from '../errors.js';
-import { decodeTasksLine } from '../schema.js';
-import type { TaskMeta, TaskRecord } from '../types.js';
-import { withFileLock } from './file-lock.js';
-
-const TASKS_FILE = 'tasks.jsonl';
-
-export interface TasksSnapshot {
-  meta: TaskMeta;
-  tasks: TaskRecord[];
-}
-
-type ReadError = JsonlParseError | JsonlValidationError | MissingMetaRecord;
-
-export function readTasksJsonl(
-  planDir: string,
-): Effect.Effect<TasksSnapshot | undefined, ReadError, FileSystem> {
-  const path = join(planDir, TASKS_FILE);
-  return Effect.gen(function* () {
-    const fs = yield* FileSystem;
-    // A read failure (missing or unreadable file) is treated as "no snapshot".
-    const maybeText = yield* Effect.option(fs.readFileString(path));
-    if (Option.isNone(maybeText)) return undefined;
-
-    const text = maybeText.value;
-    if (!text.trim()) return yield* Effect.fail(new MissingMetaRecord({ path }));
-
-    let meta: TaskMeta | undefined;
-    const tasks: TaskRecord[] = [];
-    for (const [index, raw] of text.split(/\r?\n/).entries()) {
-      if (!raw.trim()) continue;
-      const line = index + 1;
-
-      let parsed: unknown;
-      try {
-        parsed = JSON.parse(raw);
-      } catch (cause) {
-        return yield* Effect.fail(new JsonlParseError({ path, line, cause }));
-      }
-
-      const decoded = decodeTasksLine(parsed);
-      if (Either.isLeft(decoded)) {
-        return yield* Effect.fail(
-          new JsonlValidationError({ path, line, reason: decoded.left.message }),
-        );
-      }
-
-      const record = decoded.right;
-      if (record._type === 'meta') meta = record;
-      else tasks.push(record);
-    }
-
-    if (!meta) return yield* Effect.fail(new MissingMetaRecord({ path }));
-    return { meta, tasks };
-  });
-}
-
-export function writeTasksJsonl(
-  planDir: string,
-  meta: TaskMeta,
-  tasks: TaskRecord[],
-): Effect.Effect<void, PlanWriteError, FileSystem> {
-  return Effect.gen(function* () {
-    const fs = yield* FileSystem;
-    yield* fs.makeDir(planDir);
-    const content = [meta, ...tasks].map((record) => JSON.stringify(record)).join('\n') + '\n';
-    yield* fs.writeFileAtomic(join(planDir, TASKS_FILE), content);
-  });
-}
-
-export function updateTask(
-  planDir: string,
-  taskId: string,
-  updates: Partial<Omit<TaskRecord, '_type' | 'id' | 'created_at'>>,
-): Effect.Effect<
-  TaskRecord,
-  ReadError | PlanWriteError | TasksFileNotFound | TaskNotFound,
-  FileSystem
-> {
-  // Serialize the read-modify-write so concurrent task updates to the same plan
-  // (e.g. parallel update_task / update_tasks calls) cannot clobber each other.
-  return withFileLock(
-    join(planDir, TASKS_FILE),
-    Effect.gen(function* () {
-      const snapshot = yield* readTasksJsonl(planDir);
-      if (!snapshot) return yield* Effect.fail(new TasksFileNotFound({ planDir }));
-
-      const index = snapshot.tasks.findIndex((task) => task.id === taskId);
-      if (index === -1) return yield* Effect.fail(new TaskNotFound({ planDir, taskId }));
-
-      const updated: TaskRecord = {
-        ...snapshot.tasks[index],
-        ...updates,
-        updated_at: new Date().toISOString(),
-      };
-      snapshot.tasks[index] = updated;
-      yield* writeTasksJsonl(planDir, snapshot.meta, snapshot.tasks);
-      return updated;
-    }),
-  );
-}

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

@@ -1,46 +0,0 @@
-/**
- * Pure helpers for reasoning about task status at execution checkpoints.
- *
- * `deferred` tasks are discovered follow-ups kept out of the active queue, so
- * they are excluded from "resolved" checks but block plan finalization.
- */
-
-import type { TaskRecord } from './types.js';
-
-export function deferredTasks(tasks: readonly TaskRecord[]): TaskRecord[] {
-  return tasks.filter((task) => task.status === 'deferred');
-}
-
-/**
- * True when no active work remains — every task is done, skipped, or deferred
- * (nothing pending or blocked).
- */
-export function activeTasksResolved(tasks: readonly TaskRecord[]): boolean {
-  return tasks.every(
-    (task) => task.status === 'done' || task.status === 'skipped' || task.status === 'deferred',
-  );
-}
-
-/**
- * True when the plan can be marked complete: active work is resolved AND there
- * are no deferred follow-ups awaiting the user's decision.
- */
-export function isPlanFinalizable(tasks: readonly TaskRecord[]): boolean {
-  return activeTasksResolved(tasks) && !tasks.some((task) => task.status === 'deferred');
-}
-
-/**
- * Reactivate tasks for a resumed run: blocked tasks and deferred follow-ups
- * become pending (mutated in place). Returns true if anything changed.
- */
-export function reactivateForExecution(tasks: TaskRecord[], timestamp: string): boolean {
-  let changed = false;
-  for (const task of tasks) {
-    if (task.status === 'blocked' || task.status === 'deferred') {
-      task.status = 'pending';
-      task.updated_at = timestamp;
-      changed = true;
-    }
-  }
-  return changed;
-}