lsd-pi 1.0.0 → 1.1.0

package/dist/resources/extensions/gsd/undo.js

@@ -1,400 +0,0 @@
-// GSD Extension — Undo Last Unit + Targeted State Reset
-// handleUndo: Rollback the most recent completed unit (revert git, remove state, uncheck plans).
-// handleUndoTask: Reset a single task's DB status to "pending" and re-render markdown.
-// handleResetSlice: Reset a slice and all its tasks, re-rendering plan + roadmap.
-import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "node:fs";
-import { join, basename } from "node:path";
-import { nativeRevertCommit, nativeRevertAbort } from "./native-git-bridge.js";
-import { parseUnitId } from "./unit-id.js";
-import { deriveState } from "./state.js";
-import { invalidateAllCaches } from "./cache.js";
-import { gsdRoot, resolveTasksDir, resolveSlicePath, resolveTaskFile, buildTaskFileName, buildSliceFileName } from "./paths.js";
-import { sendDesktopNotification } from "./notifications.js";
-import { getTask, getSlice, getSliceTasks, updateTaskStatus, updateSliceStatus } from "./gsd-db.js";
-import { renderPlanCheckboxes, renderRoadmapCheckboxes } from "./markdown-renderer.js";
-/**
- * Undo the last completed unit: revert git commits,
- * delete summary artifacts, and uncheck the task in PLAN.
- * deriveState() handles re-derivation after revert.
- */
-export async function handleUndo(args, ctx, _pi, basePath) {
-    const force = args.includes("--force");
-    // Find the last GSD-related commit from git activity logs
-    const activityDir = join(gsdRoot(basePath), "activity");
-    if (!existsSync(activityDir)) {
-        ctx.ui.notify("Nothing to undo — no activity logs found.", "info");
-        return;
-    }
-    // Parse activity logs to find the most recent unit
-    const files = readdirSync(activityDir)
-        .filter(f => f.endsWith(".jsonl"))
-        .sort()
-        .reverse();
-    if (files.length === 0) {
-        ctx.ui.notify("Nothing to undo — no activity logs found.", "info");
-        return;
-    }
-    // Extract unit type and ID from the most recent activity log filename
-    // Format: <seq>-<unitType>-<unitId>.jsonl
-    const match = files[0].match(/^\d+-(.+?)-(.+)\.jsonl$/);
-    if (!match) {
-        ctx.ui.notify("Nothing to undo — could not parse latest activity log.", "warning");
-        return;
-    }
-    const unitType = match[1];
-    const unitId = match[2].replace(/-/g, "/");
-    if (!force) {
-        ctx.ui.notify(`Will undo: ${unitType} (${unitId})\n` +
-            `This will:\n` +
-            `  - Delete summary artifacts\n` +
-            `  - Uncheck task in PLAN (if execute-task)\n` +
-            `  - Attempt to revert associated git commits\n\n` +
-            `Run /gsd undo --force to confirm.`, "warning");
-        return;
-    }
-    // 1. Delete summary artifact
-    const { milestone, slice, task } = parseUnitId(unitId);
-    let summaryRemoved = false;
-    if (task !== undefined && slice !== undefined) {
-        // Task-level: M001/S01/T01
-        const [mid, sid, tid] = [milestone, slice, task];
-        const tasksDir = resolveTasksDir(basePath, mid, sid);
-        if (tasksDir) {
-            const summaryFile = join(tasksDir, buildTaskFileName(tid, "SUMMARY"));
-            if (existsSync(summaryFile)) {
-                unlinkSync(summaryFile);
-                summaryRemoved = true;
-            }
-        }
-    }
-    else if (slice !== undefined) {
-        // Slice-level: M001/S01
-        const [mid, sid] = [milestone, slice];
-        const slicePath = resolveSlicePath(basePath, mid, sid);
-        if (slicePath) {
-            for (const suffix of ["SUMMARY", "COMPLETE"]) {
-                const candidates = findFileWithPrefix(slicePath, sid, suffix);
-                for (const f of candidates) {
-                    unlinkSync(f);
-                    summaryRemoved = true;
-                }
-            }
-        }
-    }
-    // 2. Uncheck task in PLAN if execute-task
-    let planUpdated = false;
-    if (unitType === "execute-task" && task !== undefined && slice !== undefined) {
-        const [mid, sid, tid] = [milestone, slice, task];
-        planUpdated = uncheckTaskInPlan(basePath, mid, sid, tid);
-    }
-    // 3. Try to revert git commits from activity log
-    let commitsReverted = 0;
-    try {
-        const commits = findCommitsForUnit(activityDir, unitType, unitId);
-        if (commits.length > 0) {
-            for (const sha of commits.reverse()) {
-                try {
-                    nativeRevertCommit(basePath, sha);
-                    commitsReverted++;
-                }
-                catch {
-                    // Revert conflict or already reverted — skip
-                    try {
-                        nativeRevertAbort(basePath);
-                    }
-                    catch { /* no-op */ }
-                    break;
-                }
-            }
-        }
-    }
-    finally {
-        // 4. Re-derive state — always invalidate caches even if git operations fail
-        invalidateAllCaches();
-        await deriveState(basePath);
-    }
-    // Build result message
-    const results = [`Undone: ${unitType} (${unitId})`];
-    if (summaryRemoved)
-        results.push(`  - Deleted summary artifact`);
-    if (planUpdated)
-        results.push(`  - Unchecked task in PLAN`);
-    if (commitsReverted > 0) {
-        results.push(`  - Reverted ${commitsReverted} commit(s) (staged, not committed)`);
-        results.push(`  Review with 'git diff --cached' then 'git commit' or 'git reset HEAD'`);
-    }
-    ctx.ui.notify(results.join("\n"), "success");
-    sendDesktopNotification("GSD", `Undone: ${unitType} (${unitId})`, "info", "complete", basename(basePath));
-}
-// ─── Targeted State Reset ────────────────────────────────────────────────────
-/**
- * Parse a task identifier from args. Accepts:
- *   T01, S01/T01, M001/S01/T01
- * Resolves missing parts from current state via deriveState().
- */
-async function parseTaskId(raw, basePath) {
-    const parts = raw.split("/");
-    if (parts.length === 3) {
-        return { mid: parts[0], sid: parts[1], tid: parts[2] };
-    }
-    // Need to resolve from state
-    const state = await deriveState(basePath);
-    if (parts.length === 2) {
-        // S01/T01 — resolve milestone
-        const mid = state.activeMilestone?.id;
-        if (!mid)
-            return "Cannot resolve milestone — no active milestone in state.";
-        return { mid, sid: parts[0], tid: parts[1] };
-    }
-    if (parts.length === 1) {
-        // T01 — resolve milestone + slice
-        const mid = state.activeMilestone?.id;
-        const sid = state.activeSlice?.id;
-        if (!mid)
-            return "Cannot resolve milestone — no active milestone in state.";
-        if (!sid)
-            return "Cannot resolve slice — no active slice in state.";
-        return { mid, sid, tid: parts[0] };
-    }
-    return "Invalid task ID format. Use T01, S01/T01, or M001/S01/T01.";
-}
-/**
- * Parse a slice identifier from args. Accepts:
- *   S01, M001/S01
- * Resolves missing milestone from current state.
- */
-async function parseSliceId(raw, basePath) {
-    const parts = raw.split("/");
-    if (parts.length === 2) {
-        return { mid: parts[0], sid: parts[1] };
-    }
-    if (parts.length === 1) {
-        const state = await deriveState(basePath);
-        const mid = state.activeMilestone?.id;
-        if (!mid)
-            return "Cannot resolve milestone — no active milestone in state.";
-        return { mid, sid: parts[0] };
-    }
-    return "Invalid slice ID format. Use S01 or M001/S01.";
-}
-/**
- * Reset a single task's completion state:
- * - Set DB status to "pending"
- * - Delete the task summary file
- * - Re-render plan checkboxes
- */
-export async function handleUndoTask(args, ctx, _pi, basePath) {
-    const force = args.includes("--force");
-    const rawId = args.replace("--force", "").trim();
-    if (!rawId) {
-        ctx.ui.notify("Usage: /gsd undo-task <taskId> [--force]\n\n" +
-            "Accepts: T01, S01/T01, or M001/S01/T01\n" +
-            "Resets the task's DB status to pending and re-renders plan checkboxes.", "warning");
-        return;
-    }
-    const parsed = await parseTaskId(rawId, basePath);
-    if (typeof parsed === "string") {
-        ctx.ui.notify(parsed, "error");
-        return;
-    }
-    const { mid, sid, tid } = parsed;
-    // Validate task exists in DB
-    const task = getTask(mid, sid, tid);
-    if (!task) {
-        ctx.ui.notify(`Task ${mid}/${sid}/${tid} not found in database.`, "error");
-        return;
-    }
-    if (!force) {
-        ctx.ui.notify(`Will reset: task ${mid}/${sid}/${tid}\n` +
-            `  Current status: ${task.status}\n` +
-            `This will:\n` +
-            `  - Set task status to "pending" in DB\n` +
-            `  - Delete task summary file (if exists)\n` +
-            `  - Re-render plan checkboxes\n\n` +
-            `Run /gsd undo-task ${rawId} --force to confirm.`, "warning");
-        return;
-    }
-    // Reset DB status
-    updateTaskStatus(mid, sid, tid, "pending");
-    // Delete summary file
-    let summaryDeleted = false;
-    const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
-    if (summaryPath && existsSync(summaryPath)) {
-        unlinkSync(summaryPath);
-        summaryDeleted = true;
-    }
-    // Re-render plan checkboxes
-    await renderPlanCheckboxes(basePath, mid, sid);
-    // Invalidate caches
-    invalidateAllCaches();
-    const results = [`Reset task ${mid}/${sid}/${tid} to "pending".`];
-    if (summaryDeleted)
-        results.push("  - Deleted task summary file");
-    results.push("  - Plan checkboxes re-rendered");
-    ctx.ui.notify(results.join("\n"), "success");
-}
-/**
- * Reset a slice and all its tasks:
- * - Set all task DB statuses to "pending"
- * - Set slice DB status to "active"
- * - Delete task summary files, slice summary, and UAT files
- * - Re-render plan + roadmap checkboxes
- */
-export async function handleResetSlice(args, ctx, _pi, basePath) {
-    const force = args.includes("--force");
-    const rawId = args.replace("--force", "").trim();
-    if (!rawId) {
-        ctx.ui.notify("Usage: /gsd reset-slice <sliceId> [--force]\n\n" +
-            "Accepts: S01 or M001/S01\n" +
-            "Resets the slice and all its tasks, re-renders plan + roadmap checkboxes.", "warning");
-        return;
-    }
-    const parsed = await parseSliceId(rawId, basePath);
-    if (typeof parsed === "string") {
-        ctx.ui.notify(parsed, "error");
-        return;
-    }
-    const { mid, sid } = parsed;
-    // Validate slice exists in DB
-    const slice = getSlice(mid, sid);
-    if (!slice) {
-        ctx.ui.notify(`Slice ${mid}/${sid} not found in database.`, "error");
-        return;
-    }
-    const tasks = getSliceTasks(mid, sid);
-    if (!force) {
-        ctx.ui.notify(`Will reset: slice ${mid}/${sid}\n` +
-            `  Current status: ${slice.status}\n` +
-            `  Tasks to reset: ${tasks.length}\n` +
-            `This will:\n` +
-            `  - Set all task statuses to "pending" in DB\n` +
-            `  - Set slice status to "active" in DB\n` +
-            `  - Delete task summary files, slice summary, and UAT files\n` +
-            `  - Re-render plan + roadmap checkboxes\n\n` +
-            `Run /gsd reset-slice ${rawId} --force to confirm.`, "warning");
-        return;
-    }
-    // Reset all tasks
-    let tasksReset = 0;
-    let summariesDeleted = 0;
-    for (const t of tasks) {
-        updateTaskStatus(mid, sid, t.id, "pending");
-        tasksReset++;
-        const summaryPath = resolveTaskFile(basePath, mid, sid, t.id, "SUMMARY");
-        if (summaryPath && existsSync(summaryPath)) {
-            unlinkSync(summaryPath);
-            summariesDeleted++;
-        }
-    }
-    // Reset slice status
-    updateSliceStatus(mid, sid, "active");
-    // Delete slice summary and UAT files
-    let sliceFilesDeleted = 0;
-    const slicePath = resolveSlicePath(basePath, mid, sid);
-    if (slicePath) {
-        for (const suffix of ["SUMMARY", "UAT"]) {
-            const filePath = join(slicePath, buildSliceFileName(sid, suffix));
-            if (existsSync(filePath)) {
-                unlinkSync(filePath);
-                sliceFilesDeleted++;
-            }
-        }
-    }
-    // Re-render plan + roadmap checkboxes
-    await renderPlanCheckboxes(basePath, mid, sid);
-    await renderRoadmapCheckboxes(basePath, mid);
-    // Invalidate caches
-    invalidateAllCaches();
-    const results = [
-        `Reset slice ${mid}/${sid} to "active".`,
-        `  - ${tasksReset} task(s) reset to "pending"`,
-    ];
-    if (summariesDeleted > 0)
-        results.push(`  - ${summariesDeleted} task summary file(s) deleted`);
-    if (sliceFilesDeleted > 0)
-        results.push(`  - ${sliceFilesDeleted} slice file(s) deleted (summary/UAT)`);
-    results.push("  - Plan + roadmap checkboxes re-rendered");
-    ctx.ui.notify(results.join("\n"), "success");
-}
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-export function uncheckTaskInPlan(basePath, mid, sid, tid) {
-    const slicePath = resolveSlicePath(basePath, mid, sid);
-    if (!slicePath)
-        return false;
-    // Find the PLAN file
-    const planCandidates = findFileWithPrefix(slicePath, sid, "PLAN");
-    if (planCandidates.length === 0)
-        return false;
-    const planFile = planCandidates[0];
-    let content = readFileSync(planFile, "utf-8");
-    // Match checked task line: - [x] **T01** or - [x] T01:
-    const regex = new RegExp(`^(\\s*-\\s*)\\[x\\](\\s*\\**${tid}\\**[:\\s])`, "mi");
-    if (regex.test(content)) {
-        content = content.replace(regex, "$1[ ]$2");
-        writeFileSync(planFile, content, "utf-8");
-        return true;
-    }
-    return false;
-}
-function findFileWithPrefix(dir, prefix, suffix) {
-    try {
-        const files = readdirSync(dir);
-        return files
-            .filter(f => f.includes(suffix) && (f.startsWith(prefix) || f.startsWith(`${prefix}-`)))
-            .map(f => join(dir, f));
-    }
-    catch {
-        return [];
-    }
-}
-export function findCommitsForUnit(activityDir, unitType, unitId) {
-    const safeUnitId = unitId.replace(/\//g, "-");
-    const commitSet = new Set();
-    const commits = [];
-    try {
-        const files = readdirSync(activityDir)
-            .filter(f => f.includes(unitType) && f.includes(safeUnitId) && f.endsWith(".jsonl"))
-            .sort()
-            .reverse();
-        if (files.length === 0)
-            return [];
-        // Parse the most recent activity log for this unit
-        const content = readFileSync(join(activityDir, files[0]), "utf-8");
-        for (const line of content.split("\n")) {
-            if (!line.trim())
-                continue;
-            try {
-                const entry = JSON.parse(line);
-                // Look for tool results containing git commit output
-                if (entry?.message?.content) {
-                    const blocks = Array.isArray(entry.message.content) ? entry.message.content : [];
-                    for (const block of blocks) {
-                        if (block.type === "tool_result" && typeof block.content === "string") {
-                            for (const sha of extractCommitShas(block.content)) {
-                                if (!commitSet.has(sha)) {
-                                    commitSet.add(sha);
-                                    commits.push(sha);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            catch { /* malformed JSON line — skip */ }
-        }
-    }
-    catch { /* activity dir issues — skip */ }
-    return commits;
-}
-export function extractCommitShas(content) {
-    const seen = new Set();
-    const commits = [];
-    for (const match of content.matchAll(/\[[\w/.-]+\s+([a-f0-9]{7,40})\]/g)) {
-        const sha = match[1];
-        if (sha && !seen.has(sha)) {
-            seen.add(sha);
-            commits.push(sha);
-        }
-    }
-    return commits;
-}

package/dist/resources/extensions/gsd/unit-id.js

@@ -1,7 +0,0 @@
-// GSD Extension — Unit ID Parsing
-// Centralizes the milestone/slice/task decomposition of unit ID strings.
-/** Parse a unit ID string (e.g. "M1/S1/T1") into its milestone, slice, and task components. */
-export function parseUnitId(unitId) {
-    const [milestone, slice, task] = unitId.split("/");
-    return { milestone: milestone, slice, task };
-}

package/dist/resources/extensions/gsd/unit-ownership.js

@@ -1,216 +0,0 @@
-// GSD Extension — Unit Ownership
-// Opt-in per-unit ownership claims for multi-agent safety.
-//
-// An agent can claim a unit (task, slice) before working on it.
-// complete-task and complete-slice enforce ownership when claims exist.
-// Claims are stored in SQLite (.gsd/unit-claims.db) for atomic
-// first-writer-wins semantics via INSERT OR IGNORE.
-//
-// Unit key format:
-//   task:  "<milestoneId>/<sliceId>/<taskId>"
-//   slice: "<milestoneId>/<sliceId>"
-//
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
-import { createRequire } from "node:module";
-import { mkdirSync } from "node:fs";
-import { join } from "node:path";
-const _require = createRequire(import.meta.url);
-let providerName = null;
-let providerModule = null;
-let loadAttempted = false;
-function suppressSqliteWarning() {
-    const origEmit = process.emit;
-    // @ts-expect-error overriding process.emit for warning filter
-    process.emit = function (event, ...args) {
-        if (event === "warning" &&
-            args[0] &&
-            typeof args[0] === "object" &&
-            "name" in args[0] &&
-            args[0].name === "ExperimentalWarning" &&
-            "message" in args[0] &&
-            typeof args[0].message === "string" &&
-            args[0].message.includes("SQLite")) {
-            return false;
-        }
-        return origEmit.apply(process, [event, ...args]);
-    };
-}
-function loadProvider() {
-    if (loadAttempted)
-        return;
-    loadAttempted = true;
-    try {
-        suppressSqliteWarning();
-        const mod = _require("node:sqlite");
-        if (mod.DatabaseSync) {
-            providerModule = mod;
-            providerName = "node:sqlite";
-            return;
-        }
-    }
-    catch {
-        // unavailable
-    }
-    try {
-        const mod = _require("better-sqlite3");
-        if (typeof mod === "function" || (mod && mod.default)) {
-            providerModule = mod.default || mod;
-            providerName = "better-sqlite3";
-            return;
-        }
-    }
-    catch {
-        // unavailable
-    }
-}
-function normalizeRow(row) {
-    if (row == null)
-        return undefined;
-    if (Object.getPrototypeOf(row) === null) {
-        return { ...row };
-    }
-    return row;
-}
-function openRawDb(path) {
-    loadProvider();
-    if (!providerModule || !providerName)
-        return null;
-    if (providerName === "node:sqlite") {
-        const { DatabaseSync } = providerModule;
-        return new DatabaseSync(path);
-    }
-    const Database = providerModule;
-    return new Database(path);
-}
-function wrapDb(rawDb) {
-    const db = rawDb;
-    return {
-        exec(sql) { db.exec(sql); },
-        prepare(sql) {
-            const raw = db.prepare(sql);
-            return {
-                run(...params) { return raw.run(...params); },
-                get(...params) {
-                    return normalizeRow(raw.get(...params));
-                },
-            };
-        },
-        close() { db.close(); },
-    };
-}
-// ─── Per-basePath DB pool ────────────────────────────────────────────────
-const dbPool = new Map();
-function claimsDbPath(basePath) {
-    return join(basePath, ".gsd", "unit-claims.db");
-}
-function getDb(basePath) {
-    const existing = dbPool.get(basePath);
-    if (existing)
-        return existing;
-    return null;
-}
-// ─── Key Builders ────────────────────────────────────────────────────────
-export function taskUnitKey(milestoneId, sliceId, taskId) {
-    return `${milestoneId}/${sliceId}/${taskId}`;
-}
-export function sliceUnitKey(milestoneId, sliceId) {
-    return `${milestoneId}/${sliceId}`;
-}
-// ─── Lifecycle ───────────────────────────────────────────────────────────
-/**
- * Initialize the ownership SQLite database for a given basePath.
- * Creates .gsd/ directory and unit-claims.db with the unit_claims table.
- * Safe to call multiple times (idempotent).
- */
-export function initOwnershipTable(basePath) {
-    if (dbPool.has(basePath))
-        return;
-    const dir = join(basePath, ".gsd");
-    mkdirSync(dir, { recursive: true });
-    const raw = openRawDb(claimsDbPath(basePath));
-    if (!raw) {
-        throw new Error("No SQLite provider available for unit-ownership");
-    }
-    const db = wrapDb(raw);
-    db.exec("PRAGMA journal_mode=WAL");
-    db.exec("PRAGMA busy_timeout = 5000");
-    db.exec("PRAGMA synchronous = NORMAL");
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS unit_claims (
-      unit_key TEXT PRIMARY KEY,
-      agent_name TEXT NOT NULL,
-      claimed_at TEXT NOT NULL
-    )
-  `);
-    dbPool.set(basePath, db);
-}
-/**
- * Close the ownership database for a given basePath.
- * Safe to call even if not initialized.
- */
-export function closeOwnershipDb(basePath) {
-    const db = dbPool.get(basePath);
-    if (!db)
-        return;
-    try {
-        db.close();
-    }
-    catch { /* swallow */ }
-    dbPool.delete(basePath);
-}
-// ─── Public API ──────────────────────────────────────────────────────────
-/**
- * Claim a unit for an agent.
- * Uses INSERT OR IGNORE for atomic first-writer-wins semantics.
- * Returns true if the claim was acquired (or the same agent already owns it).
- * Returns false if a different agent already owns the unit.
- */
-export function claimUnit(basePath, unitKey, agentName) {
-    const db = getDb(basePath);
-    if (!db) {
-        // Auto-init if not already initialized (backward compat)
-        initOwnershipTable(basePath);
-        return claimUnit(basePath, unitKey, agentName);
-    }
-    // INSERT OR IGNORE: if the row already exists, this is a no-op.
-    // The PRIMARY KEY constraint on unit_key prevents duplicate claims.
-    db.prepare("INSERT OR IGNORE INTO unit_claims (unit_key, agent_name, claimed_at) VALUES (?, ?, ?)").run(unitKey, agentName, new Date().toISOString());
-    // Check who owns it now
-    const row = db.prepare("SELECT agent_name FROM unit_claims WHERE unit_key = ?").get(unitKey);
-    const owner = row?.agent_name;
-    return owner === agentName;
-}
-/**
- * Release a unit claim (remove it from the claims table).
- */
-export function releaseUnit(basePath, unitKey) {
-    const db = getDb(basePath);
-    if (!db)
-        return;
-    db.prepare("DELETE FROM unit_claims WHERE unit_key = ?").run(unitKey);
-}
-/**
- * Get the current owner of a unit, or null if unclaimed.
- */
-export function getOwner(basePath, unitKey) {
-    const db = getDb(basePath);
-    if (!db)
-        return null;
-    const row = db.prepare("SELECT agent_name FROM unit_claims WHERE unit_key = ?").get(unitKey);
-    return row?.agent_name ?? null;
-}
-/**
- * Check if an actor is authorized to operate on a unit.
- * Returns null if ownership passes (or is unclaimed).
- * Returns an error string if a different agent owns the unit.
- */
-export function checkOwnership(basePath, unitKey, actorName) {
-    if (!actorName)
-        return null; // no actor identity provided — opt-in, so allow
-    const owner = getOwner(basePath, unitKey);
-    if (owner === null)
-        return null; // unit unclaimed
-    if (owner === actorName)
-        return null; // actor is the owner
-    return `Unit ${unitKey} is owned by ${owner}, not ${actorName}`;
-}