lsd-pi 1.0.0 → 1.1.0

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

@@ -1,310 +0,0 @@
-/**
- * GSD Worktree Utilities
- *
- * Pure utility functions for worktree name detection, legacy branch name
- * parsing, and integration branch capture.
- *
- * Pure utility functions (detectWorktreeName, getSliceBranchName, parseSliceBranch,
- * SLICE_BRANCH_RE) remain standalone for backwards compatibility.
- *
- * Branchless architecture: all work commits sequentially on the milestone branch.
- * Pure utility functions (detectWorktreeName, getSliceBranchName, parseSliceBranch,
- * SLICE_BRANCH_RE) remain for backwards compatibility with legacy branches.
- */
-import { existsSync, readFileSync, realpathSync, utimesSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { homedir } from "node:os";
-import { GitServiceImpl, writeIntegrationBranch } from "./git-service.js";
-import { loadEffectiveGSDPreferences } from "./preferences.js";
-export { MergeConflictError } from "./git-service.js";
-// ─── Lazy GitServiceImpl Cache ─────────────────────────────────────────────
-let cachedService = null;
-let cachedBasePath = null;
-/**
- * Get or create a GitServiceImpl for the given basePath.
- * Resets the cache if basePath changes between calls.
- * Lazy construction: only instantiated at call-time, never at module-evaluation.
- */
-function getService(basePath) {
-    if (cachedService === null || cachedBasePath !== basePath) {
-        const loaded = loadEffectiveGSDPreferences();
-        const gitPrefs = loaded?.preferences?.git ?? {};
-        cachedService = new GitServiceImpl(basePath, gitPrefs);
-        cachedBasePath = basePath;
-    }
-    return cachedService;
-}
-/**
- * Set the active milestone ID on the cached GitServiceImpl.
- * This enables integration branch resolution in getMainBranch().
- */
-export function setActiveMilestoneId(basePath, milestoneId) {
-    getService(basePath).setMilestoneId(milestoneId);
-}
-/**
- * Record the current branch as the integration branch for a milestone.
- * Called once when auto-mode starts — captures where slice branches should
- * merge back to. No-op if the same branch is already recorded. Updates the
- * record when the user starts from a different branch (#300). Always a no-op
- * if on a GSD slice branch.
- */
-export function captureIntegrationBranch(basePath, milestoneId) {
-    // In a worktree, the base branch is implicit (worktree/<name>).
-    // Writing it to META.json would leave stale metadata after merge back to main.
-    if (detectWorktreeName(basePath))
-        return;
-    const svc = getService(basePath);
-    const current = svc.getCurrentBranch();
-    writeIntegrationBranch(basePath, milestoneId, current);
-}
-// ─── Pure Utility Functions (unchanged) ────────────────────────────────────
-/**
- * Find the worktrees segment in a path, supporting both direct
- * (`/.gsd/worktrees/`) and symlink-resolved (`/.gsd/projects/<hash>/worktrees/`)
- * layouts.  When `.gsd` is a symlink to `~/.gsd/projects/<hash>`, resolved
- * paths contain the intermediate `projects/<hash>/` segment that the old
- * single-marker check missed.
- */
-function findWorktreeSegment(normalizedPath) {
-    // Direct layout: /.gsd/worktrees/<name>
-    const directMarker = "/.gsd/worktrees/";
-    const idx = normalizedPath.indexOf(directMarker);
-    if (idx !== -1) {
-        return { gsdIdx: idx, afterWorktrees: idx + directMarker.length };
-    }
-    // Symlink-resolved layout: /.gsd/projects/<hash>/worktrees/<name>
-    const symlinkRe = /\/\.gsd\/projects\/[a-f0-9]+\/worktrees\//;
-    const match = normalizedPath.match(symlinkRe);
-    if (match && match.index !== undefined) {
-        return { gsdIdx: match.index, afterWorktrees: match.index + match[0].length };
-    }
-    return null;
-}
-/**
- * Detect the active worktree name from the current working directory.
- * Returns null if not inside a GSD worktree (.gsd/worktrees/<name>/).
- */
-export function detectWorktreeName(basePath) {
-    const normalizedPath = basePath.replaceAll("\\", "/");
-    const seg = findWorktreeSegment(normalizedPath);
-    if (!seg)
-        return null;
-    const afterMarker = normalizedPath.slice(seg.afterWorktrees);
-    const name = afterMarker.split("/")[0];
-    return name || null;
-}
-/**
- * Resolve the project root from a path that may be inside a worktree.
- * If the path contains a worktrees segment, returns the portion before
- * `/.gsd/`. Otherwise returns the input unchanged.
- *
- * When the worker was spawned with GSD_PROJECT_ROOT set, use that directly —
- * the coordinator already knows the real project root unambiguously.
- *
- * When `/.gsd/` in the resolved path is actually the user-level `~/.gsd/`
- * (common when `.gsd` is a symlink into `~/.gsd/projects/<hash>`), the
- * string-slice heuristic would return `~` — which is catastrophically wrong.
- * In that case, fall back to reading the worktree's `.git` file, which
- * contains a `gitdir:` pointer to the real project's `.git/worktrees/<name>`,
- * giving the real project root unambiguously.
- *
- * Use this in commands that call `process.cwd()` to ensure they always
- * operate against the real project root, not a worktree subdirectory.
- */
-export function resolveProjectRoot(basePath) {
-    // Layer 1: If the coordinator passed the real project root, use it.
-    if (process.env.GSD_PROJECT_ROOT) {
-        return process.env.GSD_PROJECT_ROOT;
-    }
-    const normalizedPath = basePath.replaceAll("\\", "/");
-    const seg = findWorktreeSegment(normalizedPath);
-    if (!seg)
-        return basePath;
-    // Candidate root via the string-slice heuristic
-    const sepChar = basePath.includes("\\") ? "\\" : "/";
-    const gsdMarker = `${sepChar}.gsd${sepChar}`;
-    const gsdIdx = basePath.indexOf(gsdMarker);
-    const candidate = gsdIdx !== -1
-        ? basePath.slice(0, gsdIdx)
-        : basePath.slice(0, seg.gsdIdx);
-    // Layer 2: Guard against resolving to the user's home directory.
-    // When .gsd is a symlink into ~/.gsd/projects/<hash>, the resolved path
-    // contains /.gsd/ at the user-level boundary. Slicing there yields ~ — wrong.
-    const gsdHome = normalizePathForCompare(process.env.LSD_HOME || join(homedir(), ".lsd"));
-    const candidateGsdPath = normalizePathForCompare(join(candidate, ".gsd"));
-    if (candidateGsdPath === gsdHome || candidateGsdPath.startsWith(gsdHome + "/")) {
-        // The candidate is the home directory (or within it in a way that .gsd
-        // maps to the user-level GSD dir). Try to recover the real project root
-        // from the worktree's .git file.
-        const realRoot = resolveProjectRootFromGitFile(basePath);
-        if (realRoot)
-            return realRoot;
-        // If git file resolution failed, return basePath unchanged rather than ~
-        return basePath;
-    }
-    return candidate;
-}
-/**
- * Recover the real project root from a worktree's .git file.
- *
- * Each git worktree has a `.git` file (not directory) containing:
- *   gitdir: /real/project/.git/worktrees/<name>
- *
- * Walking up from that gitdir gives us `/real/project/.git`, and its
- * parent is the real project root.
- */
-function resolveProjectRootFromGitFile(worktreePath) {
-    try {
-        // Walk up from the worktree path to find the .git file
-        let dir = worktreePath;
-        for (let i = 0; i < 30; i++) {
-            const gitPath = join(dir, ".git");
-            if (existsSync(gitPath)) {
-                const content = readFileSync(gitPath, "utf8").trim();
-                if (content.startsWith("gitdir: ")) {
-                    // gitdir points to: <real-project>/.git/worktrees/<name>
-                    const gitDir = resolve(dir, content.slice(8));
-                    // Walk up: .git/worktrees/<name> → .git/worktrees → .git → project root
-                    const dotGitDir = resolve(gitDir, "..", "..");
-                    // Verify this looks like a .git directory
-                    if (dotGitDir.endsWith(".git") || dotGitDir.endsWith(".git/") || dotGitDir.endsWith(".git\\")) {
-                        return resolve(dotGitDir, "..");
-                    }
-                    // Alternative: the commondir file inside the worktree gitdir
-                    // points to the main .git directory
-                    const commonDirPath = join(gitDir, "commondir");
-                    if (existsSync(commonDirPath)) {
-                        const commonDir = readFileSync(commonDirPath, "utf8").trim();
-                        const resolvedCommonDir = resolve(gitDir, commonDir);
-                        return resolve(resolvedCommonDir, "..");
-                    }
-                }
-                break;
-            }
-            const parent = resolve(dir, "..");
-            if (parent === dir)
-                break;
-            dir = parent;
-        }
-    }
-    catch {
-        // Non-fatal — caller will use fallback
-    }
-    return null;
-}
-function normalizePathForCompare(path) {
-    let normalized;
-    try {
-        normalized = realpathSync(path);
-    }
-    catch {
-        normalized = resolve(path);
-    }
-    const slashed = normalized.replaceAll("\\", "/");
-    const trimmed = slashed.replace(/\/+$/, "");
-    return trimmed || "/";
-}
-/**
- * Get the slice branch name, namespaced by worktree when inside one.
- *
- * In the main tree:     gsd/<milestoneId>/<sliceId>
- * In a worktree:        gsd/<worktreeName>/<milestoneId>/<sliceId>
- *
- * This prevents branch conflicts when multiple worktrees work on the
- * same milestone/slice IDs — git doesn't allow a branch to be checked
- * out in more than one worktree simultaneously.
- */
-export function getSliceBranchName(milestoneId, sliceId, worktreeName) {
-    if (worktreeName) {
-        return `gsd/${worktreeName}/${milestoneId}/${sliceId}`;
-    }
-    return `gsd/${milestoneId}/${sliceId}`;
-}
-/** Re-export for backward compatibility — canonical definition in branch-patterns.ts */
-export { SLICE_BRANCH_RE } from "./branch-patterns.js";
-import { SLICE_BRANCH_RE } from "./branch-patterns.js";
-/**
- * Parse a slice branch name into its components.
- * Handles both `gsd/M001/S01` and `gsd/myworktree/M001/S01`.
- */
-export function parseSliceBranch(branchName) {
-    const match = branchName.match(SLICE_BRANCH_RE);
-    if (!match)
-        return null;
-    return {
-        worktreeName: match[1] ?? null,
-        milestoneId: match[2],
-        sliceId: match[3],
-    };
-}
-// ─── Git-Mutation Functions (delegate to GitServiceImpl) ───────────────────
-/**
- * Get the "main" branch for GSD slice operations.
- *
- * In the main working tree: returns main/master (the repo's default branch).
- * In a worktree: returns worktree/<name> — the worktree's own base branch.
- *
- * This is critical because git doesn't allow a branch to be checked out
- * in more than one worktree. Slice branches merge into the worktree's base
- * branch, and the worktree branch later merges into the real main via
- * /worktree merge.
- */
-export function getMainBranch(basePath) {
-    return getService(basePath).getMainBranch();
-}
-export function getCurrentBranch(basePath) {
-    return getService(basePath).getCurrentBranch();
-}
-/**
- * Auto-commit any dirty files in the current working tree.
- *
- * When `taskContext` is provided, generates a meaningful conventional commit
- * message from the task summary (one-liner, inferred type, key files).
- * Falls back to a generic `chore()` message for non-task commits.
- *
- * Returns the commit message used, or null if already clean.
- */
-export function autoCommitCurrentBranch(basePath, unitType, unitId, taskContext) {
-    return getService(basePath).autoCommit(unitType, unitId, [], taskContext);
-}
-// ─── Git HEAD Resolution ────────────────────────────────────────────────────
-/**
- * Resolve the git HEAD file path for a given directory.
- * Handles both normal repos (.git is a directory) and worktrees (.git is a file
- * containing a `gitdir:` pointer to the real gitdir).
- */
-export function resolveGitHeadPath(dir) {
-    const gitPath = join(dir, ".git");
-    if (!existsSync(gitPath))
-        return null;
-    try {
-        const content = readFileSync(gitPath, "utf8").trim();
-        if (content.startsWith("gitdir: ")) {
-            const gitDir = resolve(dir, content.slice(8));
-            const headPath = join(gitDir, "HEAD");
-            return existsSync(headPath) ? headPath : null;
-        }
-        const headPath = join(dir, ".git", "HEAD");
-        return existsSync(headPath) ? headPath : null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Nudge pi's FooterDataProvider to re-read the git branch after chdir.
- * Touches HEAD in both old and new cwd to fire the fs watcher.
- */
-export function nudgeGitBranchCache(previousCwd) {
-    const now = new Date();
-    for (const dir of [previousCwd, process.cwd()]) {
-        try {
-            const headPath = resolveGitHeadPath(dir);
-            if (headPath)
-                utimesSync(headPath, now, now);
-        }
-        catch {
-            // Best-effort
-        }
-    }
-}

package/dist/resources/extensions/gsd/write-intercept.js

@@ -1,84 +0,0 @@
-// GSD Extension — Write Intercept for Agent State File Blocks
-// Detects agent attempts to write authoritative state files and returns
-// an error directing the agent to use the engine tool API instead.
-import { realpathSync } from "node:fs";
-import { resolve } from "node:path";
-/**
- * Patterns matching authoritative .gsd/ state files that agents must NOT write directly.
- *
- * Only STATE.md is blocked — it is purely engine-rendered from DB state.
- * All other .gsd/ files are agent-authored content that agents create and
- * update during discuss, plan, and execute phases:
- * - REQUIREMENTS.md — agents create during discuss, read during planning
- * - PROJECT.md — agents create during discuss, update at milestone close
- * - ROADMAP.md / PLAN.md — agents create during planning, engine renders checkboxes
- * - SUMMARY.md, KNOWLEDGE.md, CONTEXT.md — non-authoritative content
- */
-const BLOCKED_PATTERNS = [
-    // STATE.md is the only purely engine-rendered file.
-    // Case-insensitive to prevent bypass on macOS (case-insensitive APFS).
-    // (^|[/\\]) matches both absolute paths (/project/.gsd/…) and bare relative
-    // paths (.gsd/STATE.md) so a path without a leading separator is also blocked.
-    /(^|[/\\])\.gsd[/\\]STATE\.md$/i,
-    // Also match resolved symlink paths under ~/.gsd/projects/ (Pitfall #6)
-    /(^|[/\\])\.gsd[/\\]projects[/\\][^/\\]+[/\\]STATE\.md$/i,
-];
-/**
- * Bash command patterns that target STATE.md.
- * Covers common shell write patterns: redirect, tee, cp, mv, sed -i, etc.
- */
-const BASH_STATE_PATTERNS = [
-    // Redirect/pipe writes: > STATE.md, >> STATE.md, >| STATE.md
-    /[>|]+\s*\S*STATE\.md/i,
-    // tee to STATE.md
-    /\btee\b.*STATE\.md/i,
-    // cp/mv targeting STATE.md
-    /\b(cp|mv)\b.*STATE\.md/i,
-    // sed -i editing STATE.md
-    /\bsed\b.*-i.*STATE\.md/i,
-    // dd output to STATE.md
-    /\bdd\b.*of=\S*STATE\.md/i,
-];
-/**
- * Tests whether the given file path matches a blocked authoritative .gsd/ state file.
- * Resolves `..` segments via path.resolve() and attempts realpathSync for symlinks.
- */
-export function isBlockedStateFile(filePath) {
-    // Check raw path first
-    if (matchesBlockedPattern(filePath))
-        return true;
-    // Resolve ".." segments (works even for non-existing files)
-    const resolved = resolve(filePath);
-    if (resolved !== filePath && matchesBlockedPattern(resolved))
-        return true;
-    // Also try symlink resolution — file may not exist yet, so wrap in try/catch
-    try {
-        const realpath = realpathSync(filePath);
-        if (realpath !== filePath && realpath !== resolved && matchesBlockedPattern(realpath))
-            return true;
-    }
-    catch {
-        // File doesn't exist yet — path matching above is sufficient
-    }
-    return false;
-}
-/**
- * Tests whether a bash command appears to target STATE.md for writing.
- */
-export function isBashWriteToStateFile(command) {
-    return BASH_STATE_PATTERNS.some((pattern) => pattern.test(command));
-}
-function matchesBlockedPattern(path) {
-    return BLOCKED_PATTERNS.some((pattern) => pattern.test(path));
-}
-/**
- * Error message returned when an agent attempts to directly write an authoritative .gsd/ state file.
- * Directs the agent to use engine tool calls instead.
- */
-export const BLOCKED_WRITE_ERROR = `Direct writes to .gsd/STATE.md are blocked. Use engine tool calls instead:
-- To complete a task: call gsd_complete_task(milestone_id, slice_id, task_id, summary)
-- To complete a slice: call gsd_complete_slice(milestone_id, slice_id, summary, uat_result)
-- To save a decision: call gsd_save_decision(scope, decision, choice, rationale)
-- To start a task: call gsd_start_task(milestone_id, slice_id, task_id)
-- To record verification: call gsd_record_verification(milestone_id, slice_id, task_id, evidence)
-- To report a blocker: call gsd_report_blocker(milestone_id, slice_id, task_id, description)`;