lsd-pi 1.0.0 → 1.1.1

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

@@ -1,285 +0,0 @@
-/**
- * GSD bootstrappers for .gitignore and PREFERENCES.md
- *
- * Ensures baseline .gitignore exists with universally-correct patterns.
- * Creates an empty PREFERENCES.md template if it doesn't exist.
- * Both idempotent — non-destructive if already present.
- */
-import { join } from "node:path";
-import { execFileSync } from "node:child_process";
-import { existsSync, lstatSync, readFileSync, writeFileSync } from "node:fs";
-import { nativeRmCached, nativeLsFiles } from "./native-git-bridge.js";
-import { gsdRoot } from "./paths.js";
-import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
-/**
- * GSD runtime patterns for git index cleanup.
- * With external state (symlink), these are a no-op in most cases,
- * but retained for backwards compatibility during migration.
- */
-const GSD_RUNTIME_PATTERNS = [
-    ".gsd/activity/",
-    ".gsd/forensics/",
-    ".gsd/runtime/",
-    ".gsd/worktrees/",
-    ".gsd/parallel/",
-    ".gsd/auto.lock",
-    ".gsd/metrics.json",
-    ".gsd/completed-units.json",
-    ".gsd/STATE.md",
-    ".gsd/gsd.db",
-    ".gsd/gsd.db-shm", // SQLite WAL sidecar — always created alongside gsd.db (#2296)
-    ".gsd/gsd.db-wal", // SQLite WAL sidecar — always created alongside gsd.db (#2296)
-    ".gsd/journal/", // daily-rotated JSONL event journal (#2296)
-    ".gsd/doctor-history.jsonl", // doctor run history (#2296)
-    ".gsd/DISCUSSION-MANIFEST.json",
-    ".gsd/milestones/**/*-CONTINUE.md",
-    ".gsd/milestones/**/continue.md",
-];
-const BASELINE_PATTERNS = [
-    // ── GSD state directory (symlink to external storage) ──
-    ".gsd",
-    ".gsd-id",
-    // ── OS junk ──
-    ".DS_Store",
-    "Thumbs.db",
-    // ── Editor / IDE ──
-    "*.swp",
-    "*.swo",
-    "*~",
-    ".idea/",
-    ".vscode/",
-    "*.code-workspace",
-    // ── Environment / secrets ──
-    ".env",
-    ".env.*",
-    "!.env.example",
-    // ── Node / JS / TS ──
-    "node_modules/",
-    ".next/",
-    "dist/",
-    "build/",
-    // ── Python ──
-    "__pycache__/",
-    "*.pyc",
-    ".venv/",
-    "venv/",
-    // ── Rust ──
-    "target/",
-    // ── Go ──
-    "vendor/",
-    // ── Misc build artifacts ──
-    "*.log",
-    "coverage/",
-    ".cache/",
-    "tmp/",
-];
-/**
- * Check whether `.gsd` is covered by the project's `.gitignore`.
- *
- * Uses `git check-ignore` for accurate evaluation — this respects nested
- * .gitignore files, global gitignore, and negation patterns. Returns true
- * only when git would actually ignore `.gsd/`.
- *
- * Returns false (not ignored) if:
- *   - No `.gitignore` exists
- *   - `.gsd` is not listed in any active ignore rule
- *   - Not a git repo or git is unavailable
- */
-export function isGsdGitignored(basePath) {
-    // Check both `.gsd` and `.gsd/` because `.gsd/` in .gitignore (trailing
-    // slash = directory-only pattern) only matches the directory form. Using
-    // both paths covers all gitignore pattern variants.
-    for (const path of [".gsd", ".gsd/"]) {
-        try {
-            // git check-ignore exits 0 when the path IS ignored, 1 when it is NOT.
-            execFileSync("git", ["check-ignore", "-q", path], {
-                cwd: basePath,
-                stdio: "pipe",
-                env: GIT_NO_PROMPT_ENV,
-            });
-            return true; // exit 0 → .gsd is ignored
-        }
-        catch {
-            // exit 1 → this form is NOT ignored, try the other
-        }
-    }
-    return false; // neither form is ignored (or git unavailable)
-}
-/**
- * Check whether `.gsd/` contains files tracked by git.
- * If so, the project intentionally keeps `.gsd/` in version control
- * and we must NOT add `.gsd` to `.gitignore` or attempt migration.
- *
- * Returns true if git tracks at least one file under `.gsd/`.
- * Returns false (safe to ignore) if:
- *   - Not a git repo
- *   - `.gsd/` is a symlink (external state, should be ignored)
- *   - `.gsd/` doesn't exist
- *   - No tracked files found under `.gsd/`
- */
-export function hasGitTrackedGsdFiles(basePath) {
-    const localGsd = join(basePath, ".gsd");
-    // If .gsd doesn't exist or is already a symlink, no tracked files concern
-    if (!existsSync(localGsd))
-        return false;
-    try {
-        if (lstatSync(localGsd).isSymbolicLink())
-            return false;
-    }
-    catch {
-        return false;
-    }
-    // Check if git tracks any files under .gsd/
-    try {
-        const tracked = nativeLsFiles(basePath, ".gsd");
-        if (tracked.length > 0)
-            return true;
-        // nativeLsFiles swallows git failures and returns []. An empty result
-        // could mean "nothing tracked" OR "git failed silently". Verify git is
-        // reachable before trusting the empty result — if it isn't, fail safe
-        // by assuming files ARE tracked to prevent data loss.
-        execFileSync("git", ["rev-parse", "--git-dir"], {
-            cwd: basePath,
-            stdio: "pipe",
-            env: GIT_NO_PROMPT_ENV,
-        });
-        return false;
-    }
-    catch {
-        // git unavailable, index locked, or repo corrupt — fail safe
-        return true;
-    }
-}
-/**
- * Ensure basePath/.gitignore contains baseline ignore patterns.
- * Creates the file if missing; appends missing patterns.
- * Returns true if the file was created or modified, false if already complete.
- *
- * **Safety check:** If `.gsd/` contains git-tracked files (i.e., the project
- * intentionally keeps `.gsd/` in version control), the `.gsd` ignore pattern
- * is excluded to prevent data loss. Only the `.gsd` pattern is affected —
- * all other baseline patterns are still applied normally.
- */
-export function ensureGitignore(basePath, options) {
-    // If manage_gitignore is explicitly false, do not touch .gitignore at all
-    if (options?.manageGitignore === false)
-        return false;
-    const gitignorePath = join(basePath, ".gitignore");
-    let existing = "";
-    if (existsSync(gitignorePath)) {
-        existing = readFileSync(gitignorePath, "utf-8");
-    }
-    // Parse existing lines (trimmed, ignoring comments and blanks)
-    const existingLines = new Set(existing
-        .split("\n")
-        .map((l) => l.trim())
-        .filter((l) => l && !l.startsWith("#")));
-    // Determine which patterns to apply. If .gsd/ has tracked files,
-    // exclude the ".gsd" pattern to prevent deleting tracked state.
-    const gsdIsTracked = hasGitTrackedGsdFiles(basePath);
-    const patternsToApply = gsdIsTracked
-        ? BASELINE_PATTERNS.filter((p) => p !== ".gsd")
-        : BASELINE_PATTERNS;
-    // Find patterns not yet present
-    const missing = patternsToApply.filter((p) => !existingLines.has(p));
-    if (missing.length === 0)
-        return false;
-    // Build the block to append
-    const block = [
-        "",
-        "# ── GSD baseline (auto-generated) ──",
-        ...missing,
-        "",
-    ].join("\n");
-    // Ensure existing content ends with a newline before appending
-    const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
-    writeFileSync(gitignorePath, existing + prefix + block, "utf-8");
-    return true;
-}
-/**
- * Remove BASELINE_PATTERNS runtime paths from the git index if they are
- * currently tracked. This fixes repos that started tracking these files
- * before the .gitignore rule was added — git continues tracking files
- * already in the index even after .gitignore is updated.
- *
- * Only removes from the index (`--cached`), never from disk. Idempotent.
- *
- * Note: These are strictly runtime/ephemeral paths (activity logs, lock files,
- * metrics, STATE.md). They are always safe to untrack, even when the project
- * intentionally keeps other `.gsd/` files (like PROJECT.md, milestones/) in
- * version control.
- */
-export function untrackRuntimeFiles(basePath) {
-    const runtimePaths = GSD_RUNTIME_PATTERNS;
-    for (const pattern of runtimePaths) {
-        // Use -r for directory patterns (trailing slash), strip the slash for the command
-        const target = pattern.endsWith("/") ? pattern.slice(0, -1) : pattern;
-        try {
-            nativeRmCached(basePath, [target]);
-        }
-        catch {
-            // File not tracked or doesn't exist — expected, ignore
-        }
-    }
-}
-/**
- * Ensure basePath/.gsd/PREFERENCES.md exists as an empty template.
- * Creates the file with frontmatter only if it doesn't exist.
- * Returns true if created, false if already exists.
- *
- * Checks both uppercase (canonical) and lowercase (legacy) to avoid
- * creating a duplicate when a lowercase file already exists.
- */
-export function ensurePreferences(basePath) {
-    const preferencesPath = join(gsdRoot(basePath), "PREFERENCES.md");
-    const legacyPath = join(gsdRoot(basePath), "preferences.md");
-    if (existsSync(preferencesPath) || existsSync(legacyPath)) {
-        return false;
-    }
-    const template = `---
-version: 1
-always_use_skills: []
-prefer_skills: []
-avoid_skills: []
-skill_rules: []
-custom_instructions: []
-models: {}
-skill_discovery: {}
-auto_supervisor: {}
----
-
-# GSD Skill Preferences
-
-Project-specific guidance for skill selection and execution preferences.
-
-See \`~/.gsd/agent/extensions/gsd/docs/preferences-reference.md\` for full field documentation and examples.
-
-## Fields
-
-- \`always_use_skills\`: Skills that must be available during all GSD operations
-- \`prefer_skills\`: Skills to prioritize when multiple options exist
-- \`avoid_skills\`: Skills to minimize or avoid (with lower priority than prefer)
-- \`skill_rules\`: Context-specific rules (e.g., "use tool X for Y type of work")
-- \`custom_instructions\`: Append-only project guidance (do not override system rules)
-- \`models\`: Model preferences for specific task types
-- \`skill_discovery\`: Automatic skill detection preferences
-- \`auto_supervisor\`: Supervision and gating rules for autonomous modes
-- \`git\`: Git preferences — \`main_branch\` (default branch name for new repos, e.g., "main", "master", "trunk"), \`auto_push\`, \`snapshots\`, etc.
-
-## Examples
-
-\`\`\`yaml
-prefer_skills:
-  - playwright
-  - resolve_library
-avoid_skills:
-  - subagent  # prefer direct execution in this project
-
-custom_instructions:
-  - "Always verify with browser_assert before marking UI work done"
-  - "Use Context7 for all library/framework decisions"
-\`\`\`
-`;
-    writeFileSync(preferencesPath, template, "utf-8");
-    return true;
-}

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

@@ -1,225 +0,0 @@
-/**
- * graph.ts — Pure data module for GRAPH.yaml workflow step tracking.
- *
- * Provides types and functions for reading, writing, and querying the
- * step graph that drives CustomWorkflowEngine. Zero engine dependencies.
- *
- * GRAPH.yaml lives in a run directory and tracks step statuses
- * (pending → active → complete) with optional dependency edges.
- *
- * Observability:
- * - readGraph/writeGraph use YAML on disk — human-readable, diffable,
- *   inspectable with `cat` or any YAML viewer.
- * - Each GraphStep has status, startedAt, finishedAt fields visible in GRAPH.yaml.
- * - writeGraph uses atomic write (tmp + rename) for crash safety.
- * - All operations are immutable — callers always get a new graph object.
- */
-import { parse, stringify } from "yaml";
-import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-// ─── YAML schema mapping ─────────────────────────────────────────────────
-const GRAPH_FILENAME = "GRAPH.yaml";
-// ─── Functions ───────────────────────────────────────────────────────────
-/**
- * Read and parse GRAPH.yaml from a run directory.
- *
- * @param runDir — directory containing GRAPH.yaml
- * @returns Parsed workflow graph
- * @throws Error if file doesn't exist or YAML is malformed
- */
-export function readGraph(runDir) {
-    const filePath = join(runDir, GRAPH_FILENAME);
-    if (!existsSync(filePath)) {
-        throw new Error(`GRAPH.yaml not found: ${filePath}`);
-    }
-    const raw = readFileSync(filePath, "utf-8");
-    const yaml = parse(raw);
-    if (!yaml?.steps || !Array.isArray(yaml.steps)) {
-        throw new Error(`Invalid GRAPH.yaml: missing or invalid 'steps' array in ${filePath}`);
-    }
-    return {
-        steps: yaml.steps.map((s) => ({
-            id: s.id,
-            title: s.title,
-            status: s.status,
-            prompt: s.prompt,
-            dependsOn: s.depends_on ?? [],
-            ...(s.parent_step_id != null ? { parentStepId: s.parent_step_id } : {}),
-            ...(s.started_at != null ? { startedAt: s.started_at } : {}),
-            ...(s.finished_at != null ? { finishedAt: s.finished_at } : {}),
-        })),
-        metadata: {
-            name: yaml.metadata?.name ?? "unnamed",
-            createdAt: yaml.metadata?.created_at ?? new Date().toISOString(),
-        },
-    };
-}
-/**
- * Write a workflow graph to GRAPH.yaml in a run directory.
- * Creates the directory if it doesn't exist. Write is atomic (write + rename).
- *
- * @param runDir — directory to write GRAPH.yaml into
- * @param graph — the workflow graph to serialize
- */
-export function writeGraph(runDir, graph) {
-    if (!existsSync(runDir)) {
-        mkdirSync(runDir, { recursive: true });
-    }
-    const yamlData = {
-        steps: graph.steps.map((s) => ({
-            id: s.id,
-            title: s.title,
-            status: s.status,
-            prompt: s.prompt,
-            depends_on: s.dependsOn.length > 0 ? s.dependsOn : undefined,
-            parent_step_id: s.parentStepId ?? undefined,
-            started_at: s.startedAt ?? undefined,
-            finished_at: s.finishedAt ?? undefined,
-        })),
-        metadata: {
-            name: graph.metadata.name,
-            created_at: graph.metadata.createdAt,
-        },
-    };
-    const filePath = join(runDir, GRAPH_FILENAME);
-    const tmpPath = filePath + ".tmp";
-    const content = stringify(yamlData);
-    writeFileSync(tmpPath, content, "utf-8");
-    // Atomic rename for crash safety
-    renameSync(tmpPath, filePath);
-}
-/**
- * Get the next pending step whose dependencies are all complete.
- *
- * Returns the first step (in array order) with status "pending" where
- * every step in its `dependsOn` list has status "complete".
- *
- * @param graph — the workflow graph to query
- * @returns The next dispatchable step, or null if none available
- */
-export function getNextPendingStep(graph) {
-    const statusMap = new Map(graph.steps.map((s) => [s.id, s.status]));
-    for (const step of graph.steps) {
-        if (step.status !== "pending")
-            continue;
-        const depsComplete = step.dependsOn.every((depId) => statusMap.get(depId) === "complete");
-        if (depsComplete)
-            return step;
-    }
-    return null;
-}
-/**
- * Return a new graph with the specified step marked as "complete".
- * Immutable — does not mutate the input graph.
- *
- * @param graph — the current workflow graph
- * @param stepId — ID of the step to mark complete
- * @returns New graph with the step's status set to "complete"
- * @throws Error if stepId is not found in the graph
- */
-export function markStepComplete(graph, stepId) {
-    const found = graph.steps.some((s) => s.id === stepId);
-    if (!found) {
-        throw new Error(`Step not found: ${stepId}`);
-    }
-    return {
-        ...graph,
-        steps: graph.steps.map((s) => s.id === stepId
-            ? { ...s, status: "complete", finishedAt: new Date().toISOString() }
-            : s),
-    };
-}
-// ─── Iteration expansion ─────────────────────────────────────────────────
-/**
- * Expand an iterate step into concrete instances. Pure and deterministic —
- * identical inputs always produce identical output.
- *
- * Given a parent step with status "pending" and an array of matched items,
- * creates one instance step per item, marks the parent as "expanded", and
- * rewrites any downstream dependsOn references from the parent ID to the
- * full set of instance IDs.
- *
- * @param graph — the current workflow graph (not mutated)
- * @param stepId — ID of the iterate step to expand
- * @param items — matched items from the source artifact
- * @param promptTemplate — template with {{item}} placeholders
- * @returns New WorkflowGraph with instances inserted and deps rewritten
- * @throws Error if stepId not found or step is not pending
- */
-export function expandIteration(graph, stepId, items, promptTemplate) {
-    const parentIndex = graph.steps.findIndex((s) => s.id === stepId);
-    if (parentIndex === -1) {
-        throw new Error(`expandIteration: step not found: ${stepId}`);
-    }
-    const parentStep = graph.steps[parentIndex];
-    if (parentStep.status !== "pending") {
-        throw new Error(`expandIteration: step "${stepId}" has status "${parentStep.status}", expected "pending"`);
-    }
-    // Create instance steps
-    const instanceIds = [];
-    const instances = items.map((item, i) => {
-        const instanceId = `${stepId}--${String(i + 1).padStart(3, "0")}`;
-        instanceIds.push(instanceId);
-        return {
-            id: instanceId,
-            title: `${parentStep.title}: ${item}`,
-            status: "pending",
-            prompt: promptTemplate.replace(/\{\{item\}\}/g, () => item),
-            dependsOn: [...parentStep.dependsOn],
-            parentStepId: stepId,
-        };
-    });
-    // Build new steps array: copy everything, mark parent as expanded,
-    // insert instances right after the parent, rewrite downstream deps.
-    const newSteps = [];
-    for (let i = 0; i < graph.steps.length; i++) {
-        if (i === parentIndex) {
-            // Mark parent as expanded
-            newSteps.push({ ...parentStep, status: "expanded" });
-            // Insert instances immediately after parent
-            newSteps.push(...instances);
-        }
-        else {
-            const step = graph.steps[i];
-            // Rewrite dependsOn: replace parent ID with all instance IDs
-            const hasDep = step.dependsOn.includes(stepId);
-            if (hasDep) {
-                const rewritten = step.dependsOn.flatMap((dep) => dep === stepId ? instanceIds : [dep]);
-                newSteps.push({ ...step, dependsOn: rewritten });
-            }
-            else {
-                newSteps.push(step);
-            }
-        }
-    }
-    return {
-        ...graph,
-        steps: newSteps,
-    };
-}
-// ─── Definition → Graph conversion ──────────────────────────────────────
-/**
- * Convert a parsed WorkflowDefinition into a WorkflowGraph with all
- * steps in "pending" status. Used by run-manager to generate the initial
- * GRAPH.yaml for a new run.
- *
- * @param def — a validated WorkflowDefinition from definition-loader
- * @returns WorkflowGraph with pending steps and metadata from the definition
- */
-export function initializeGraph(def) {
-    return {
-        steps: def.steps.map((s) => ({
-            id: s.id,
-            title: s.name,
-            status: "pending",
-            prompt: s.prompt,
-            dependsOn: s.requires ?? [],
-        })),
-        metadata: {
-            name: def.name,
-            createdAt: new Date().toISOString(),
-        },
-    };
-}
-/** @deprecated Use initializeGraph instead. Kept for backward compatibility. */
-export { initializeGraph as graphFromDefinition };