gsd-pi 2.33.1-dev.29a8268 → 2.33.1-dev.bf822e6

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

@@ -0,0 +1,373 @@
+/**
+ * GSD Detection — Project state and ecosystem detection.
+ *
+ * Pure functions, zero UI dependencies, zero side effects.
+ * Used by init-wizard.ts and guided-flow.ts to determine what onboarding
+ * flow to show when entering a project directory.
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { gsdRoot } from "./paths.js";
+// ─── Project File Markers ───────────────────────────────────────────────────────
+const PROJECT_FILES = [
+    "package.json",
+    "Cargo.toml",
+    "go.mod",
+    "pyproject.toml",
+    "setup.py",
+    "Gemfile",
+    "pom.xml",
+    "build.gradle",
+    "build.gradle.kts",
+    "CMakeLists.txt",
+    "Makefile",
+    "composer.json",
+    "pubspec.yaml",
+    "Package.swift",
+    "mix.exs",
+    "deno.json",
+    "deno.jsonc",
+];
+const LANGUAGE_MAP = {
+    "package.json": "javascript/typescript",
+    "Cargo.toml": "rust",
+    "go.mod": "go",
+    "pyproject.toml": "python",
+    "setup.py": "python",
+    "Gemfile": "ruby",
+    "pom.xml": "java",
+    "build.gradle": "java/kotlin",
+    "build.gradle.kts": "kotlin",
+    "CMakeLists.txt": "c/c++",
+    "composer.json": "php",
+    "pubspec.yaml": "dart/flutter",
+    "Package.swift": "swift",
+    "mix.exs": "elixir",
+    "deno.json": "typescript/deno",
+    "deno.jsonc": "typescript/deno",
+};
+const MONOREPO_MARKERS = [
+    "lerna.json",
+    "nx.json",
+    "turbo.json",
+    "pnpm-workspace.yaml",
+];
+const CI_MARKERS = [
+    ".github/workflows",
+    ".gitlab-ci.yml",
+    "Jenkinsfile",
+    ".circleci",
+    ".travis.yml",
+    "azure-pipelines.yml",
+    "bitbucket-pipelines.yml",
+];
+const TEST_MARKERS = [
+    "__tests__",
+    "tests",
+    "test",
+    "spec",
+    "jest.config.js",
+    "jest.config.ts",
+    "vitest.config.ts",
+    "vitest.config.js",
+    ".mocharc.yml",
+    "pytest.ini",
+    "conftest.py",
+    "phpunit.xml",
+];
+// ─── Core Detection ─────────────────────────────────────────────────────────────
+/**
+ * Detect the full project state for a given directory.
+ * This is the main entry point — calls all sub-detectors.
+ */
+export function detectProjectState(basePath) {
+    const v1 = detectV1Planning(basePath);
+    const v2 = detectV2Gsd(basePath);
+    const projectSignals = detectProjectSignals(basePath);
+    const globalSetup = hasGlobalSetup();
+    const firstEver = isFirstEverLaunch();
+    let state;
+    if (v2 && v2.milestoneCount > 0) {
+        state = "v2-gsd";
+    }
+    else if (v2 && v2.milestoneCount === 0) {
+        state = "v2-gsd-empty";
+    }
+    else if (v1) {
+        state = "v1-planning";
+    }
+    else {
+        state = "none";
+    }
+    return {
+        state,
+        isFirstEverLaunch: firstEver,
+        hasGlobalSetup: globalSetup,
+        v1: v1 ?? undefined,
+        v2: v2 ?? undefined,
+        projectSignals,
+    };
+}
+// ─── V1 Planning Detection ──────────────────────────────────────────────────────
+/**
+ * Detect a v1 .planning/ directory with GSD v1 markers.
+ * Returns null if no .planning/ directory found.
+ */
+export function detectV1Planning(basePath) {
+    const planningPath = join(basePath, ".planning");
+    if (!existsSync(planningPath))
+        return null;
+    try {
+        const stat = statSync(planningPath);
+        if (!stat.isDirectory())
+            return null;
+    }
+    catch {
+        return null;
+    }
+    const hasRoadmap = existsSync(join(planningPath, "ROADMAP.md"));
+    const phasesPath = join(planningPath, "phases");
+    const hasPhasesDir = existsSync(phasesPath);
+    let phaseCount = 0;
+    if (hasPhasesDir) {
+        try {
+            const entries = readdirSync(phasesPath, { withFileTypes: true });
+            phaseCount = entries.filter(e => e.isDirectory()).length;
+        }
+        catch {
+            // unreadable — report 0
+        }
+    }
+    return {
+        path: planningPath,
+        hasPhasesDir,
+        hasRoadmap,
+        phaseCount,
+    };
+}
+// ─── V2 GSD Detection ──────────────────────────────────────────────────────────
+function detectV2Gsd(basePath) {
+    const gsdPath = gsdRoot(basePath);
+    if (!existsSync(gsdPath))
+        return null;
+    const hasPreferences = existsSync(join(gsdPath, "preferences.md")) ||
+        existsSync(join(gsdPath, "PREFERENCES.md"));
+    const hasContext = existsSync(join(gsdPath, "CONTEXT.md"));
+    let milestoneCount = 0;
+    const milestonesPath = join(gsdPath, "milestones");
+    if (existsSync(milestonesPath)) {
+        try {
+            const entries = readdirSync(milestonesPath, { withFileTypes: true });
+            milestoneCount = entries.filter(e => e.isDirectory()).length;
+        }
+        catch {
+            // unreadable — report 0
+        }
+    }
+    return { milestoneCount, hasPreferences, hasContext };
+}
+// ─── Project Signals Detection ──────────────────────────────────────────────────
+/**
+ * Quick filesystem scan for project ecosystem markers.
+ * Reads only file existence + minimal content (package.json for monorepo/scripts).
+ */
+export function detectProjectSignals(basePath) {
+    const detectedFiles = [];
+    let primaryLanguage;
+    // Detect project files
+    for (const file of PROJECT_FILES) {
+        if (existsSync(join(basePath, file))) {
+            detectedFiles.push(file);
+            if (!primaryLanguage) {
+                primaryLanguage = LANGUAGE_MAP[file];
+            }
+        }
+    }
+    // Git repo detection
+    const isGitRepo = existsSync(join(basePath, ".git"));
+    // Monorepo detection
+    let isMonorepo = false;
+    for (const marker of MONOREPO_MARKERS) {
+        if (existsSync(join(basePath, marker))) {
+            isMonorepo = true;
+            break;
+        }
+    }
+    // Also check package.json workspaces
+    if (!isMonorepo && detectedFiles.includes("package.json")) {
+        isMonorepo = packageJsonHasWorkspaces(basePath);
+    }
+    // CI detection
+    let hasCI = false;
+    for (const marker of CI_MARKERS) {
+        if (existsSync(join(basePath, marker))) {
+            hasCI = true;
+            break;
+        }
+    }
+    // Test detection
+    let hasTests = false;
+    for (const marker of TEST_MARKERS) {
+        if (existsSync(join(basePath, marker))) {
+            hasTests = true;
+            break;
+        }
+    }
+    // Package manager detection
+    const packageManager = detectPackageManager(basePath);
+    // Verification commands
+    const verificationCommands = detectVerificationCommands(basePath, detectedFiles, packageManager);
+    return {
+        detectedFiles,
+        isGitRepo,
+        isMonorepo,
+        primaryLanguage,
+        hasCI,
+        hasTests,
+        packageManager,
+        verificationCommands,
+    };
+}
+// ─── Package Manager Detection ──────────────────────────────────────────────────
+function detectPackageManager(basePath) {
+    if (existsSync(join(basePath, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (existsSync(join(basePath, "yarn.lock")))
+        return "yarn";
+    if (existsSync(join(basePath, "bun.lockb")) || existsSync(join(basePath, "bun.lock")))
+        return "bun";
+    if (existsSync(join(basePath, "package-lock.json")))
+        return "npm";
+    if (existsSync(join(basePath, "package.json")))
+        return "npm";
+    return undefined;
+}
+// ─── Verification Command Detection ─────────────────────────────────────────────
+/**
+ * Auto-detect verification commands from project files.
+ * Returns commands in priority order (test first, then build, then lint).
+ */
+function detectVerificationCommands(basePath, detectedFiles, packageManager) {
+    const commands = [];
+    const pm = packageManager ?? "npm";
+    const run = pm === "npm" ? "npm run" : pm === "yarn" ? "yarn" : pm === "bun" ? "bun run" : `${pm} run`;
+    if (detectedFiles.includes("package.json")) {
+        const scripts = readPackageJsonScripts(basePath);
+        if (scripts) {
+            // Test commands (highest priority)
+            if (scripts.test && scripts.test !== "echo \"Error: no test specified\" && exit 1") {
+                commands.push(pm === "npm" ? "npm test" : `${pm} test`);
+            }
+            // Build commands
+            if (scripts.build) {
+                commands.push(`${run} build`);
+            }
+            // Lint commands
+            if (scripts.lint) {
+                commands.push(`${run} lint`);
+            }
+            // Typecheck commands
+            if (scripts.typecheck) {
+                commands.push(`${run} typecheck`);
+            }
+            else if (scripts.tsc) {
+                commands.push(`${run} tsc`);
+            }
+        }
+    }
+    if (detectedFiles.includes("Cargo.toml")) {
+        commands.push("cargo test");
+        commands.push("cargo clippy");
+    }
+    if (detectedFiles.includes("go.mod")) {
+        commands.push("go test ./...");
+        commands.push("go vet ./...");
+    }
+    if (detectedFiles.includes("pyproject.toml") || detectedFiles.includes("setup.py")) {
+        commands.push("pytest");
+    }
+    if (detectedFiles.includes("Gemfile")) {
+        // Check for rspec vs minitest
+        if (existsSync(join(basePath, "spec"))) {
+            commands.push("bundle exec rspec");
+        }
+        else {
+            commands.push("bundle exec rake test");
+        }
+    }
+    if (detectedFiles.includes("Makefile")) {
+        const makeTargets = readMakefileTargets(basePath);
+        if (makeTargets.includes("test")) {
+            commands.push("make test");
+        }
+    }
+    return commands;
+}
+// ─── Global Setup Detection ─────────────────────────────────────────────────────
+/**
+ * Check if global GSD setup exists (has ~/.gsd/ with preferences).
+ */
+export function hasGlobalSetup() {
+    const gsdHome = join(homedir(), ".gsd");
+    return (existsSync(join(gsdHome, "preferences.md")) ||
+        existsSync(join(gsdHome, "PREFERENCES.md")));
+}
+/**
+ * Check if this is the very first time GSD has been used on this machine.
+ * Returns true if ~/.gsd/ doesn't exist or has no preferences or auth.
+ */
+export function isFirstEverLaunch() {
+    const gsdHome = join(homedir(), ".gsd");
+    if (!existsSync(gsdHome))
+        return true;
+    // If we have preferences, not first launch
+    if (existsSync(join(gsdHome, "preferences.md")) ||
+        existsSync(join(gsdHome, "PREFERENCES.md"))) {
+        return false;
+    }
+    // If we have auth.json, not first launch (onboarding.ts already ran)
+    if (existsSync(join(gsdHome, "agent", "auth.json")))
+        return false;
+    // Check legacy path too
+    const legacyPath = join(homedir(), ".pi", "agent", "gsd-preferences.md");
+    if (existsSync(legacyPath))
+        return false;
+    return true;
+}
+// ─── Helpers ────────────────────────────────────────────────────────────────────
+function packageJsonHasWorkspaces(basePath) {
+    try {
+        const raw = readFileSync(join(basePath, "package.json"), "utf-8");
+        const pkg = JSON.parse(raw);
+        return Array.isArray(pkg.workspaces) || (pkg.workspaces && typeof pkg.workspaces === "object");
+    }
+    catch {
+        return false;
+    }
+}
+function readPackageJsonScripts(basePath) {
+    try {
+        const raw = readFileSync(join(basePath, "package.json"), "utf-8");
+        const pkg = JSON.parse(raw);
+        return pkg.scripts && typeof pkg.scripts === "object" ? pkg.scripts : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readMakefileTargets(basePath) {
+    try {
+        const raw = readFileSync(join(basePath, "Makefile"), "utf-8");
+        const targets = [];
+        for (const line of raw.split("\n")) {
+            const match = line.match(/^([a-zA-Z_][a-zA-Z0-9_-]*):/);
+            if (match)
+                targets.push(match[1]);
+        }
+        return targets;
+    }
+    catch {
+        return [];
+    }
+}

package/dist/resources/extensions/gsd/diff-context.js

@@ -0,0 +1,168 @@
+/**
+ * Diff-aware context module — prioritizes recently-changed files when building
+ * context for the AI agent. Uses git diff/status to discover changes, then
+ * provides ranking utilities for context-window budget allocation.
+ *
+ * Standalone module: only imports node:child_process and node:path.
+ */
+import { execFileSync, execFile } from "node:child_process";
+import { resolve } from "node:path";
+import { GSDError, GSD_PARSE_ERROR } from "./errors.js";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+const EXEC_OPTS = {
+    encoding: "utf-8",
+    timeout: 5000,
+    stdio: ["pipe", "pipe", "pipe"],
+};
+/** Synchronous git — used where sequential control flow is required (fallback paths). */
+function gitSync(args, cwd) {
+    return execFileSync("git", args, { ...EXEC_OPTS, cwd }).trim();
+}
+/** Async git — returns stdout on success, empty string on any error. */
+function gitAsync(args, cwd) {
+    return new Promise((resolve) => {
+        execFile("git", args, { encoding: "utf-8", timeout: 5000, cwd }, (err, stdout) => resolve(err ? "" : stdout.trim()));
+    });
+}
+function splitLines(output) {
+    return output
+        .split("\n")
+        .map((l) => l.trim())
+        .filter(Boolean);
+}
+// ─── Public API ─────────────────────────────────────────────────────────────
+/**
+ * Returns recently-changed file paths, deduplicated and sorted by recency
+ * (most recent first). Combines committed diffs, staged changes, and
+ * unstaged/untracked files from `git status`.
+ *
+ * The three git queries (log, diff --cached, status) run concurrently.
+ */
+export async function getRecentlyChangedFiles(cwd, options) {
+    const maxFiles = options?.maxFiles ?? 20;
+    const sinceDays = options?.sinceDays ?? 7;
+    const dir = resolve(cwd);
+    try {
+        const days = Math.max(1, Math.floor(Number(sinceDays)));
+        if (!Number.isFinite(days))
+            throw new GSDError(GSD_PARSE_ERROR, "invalid sinceDays");
+        // Run all three queries concurrently — they read independent git state
+        const [logRaw, stagedRaw, statusRaw] = await Promise.all([
+            // 1. Committed changes since N days ago (fallback to HEAD~10 on error)
+            gitAsync(["log", "--diff-filter=ACMR", "--name-only", "--pretty=format:", `--since=${days} days ago`], dir)
+                .then((out) => out || gitAsync(["diff", "--name-only", "HEAD~10"], dir)),
+            // 2. Staged changes
+            gitAsync(["diff", "--cached", "--name-only"], dir),
+            // 3. Unstaged / untracked
+            gitAsync(["status", "--porcelain"], dir),
+        ]);
+        const committedFiles = splitLines(logRaw);
+        const stagedFiles = splitLines(stagedRaw);
+        const statusFiles = splitLines(statusRaw).map((line) => line.slice(3)); // strip XY + space
+        // Deduplicate, preserving insertion order (most-recent-first: status → staged → committed)
+        const seen = new Set();
+        const result = [];
+        for (const file of [...statusFiles, ...stagedFiles, ...committedFiles]) {
+            if (!seen.has(file)) {
+                seen.add(file);
+                result.push(file);
+            }
+        }
+        return result.slice(0, maxFiles);
+    }
+    catch {
+        // Non-git directory or git unavailable — graceful fallback
+        return [];
+    }
+}
+/**
+ * Returns richer change metadata: change type and approximate line counts.
+ *
+ * The three git queries (diff --cached --numstat, diff --numstat, status --porcelain)
+ * run concurrently — they read independent git state.
+ */
+export async function getChangedFilesWithContext(cwd) {
+    const dir = resolve(cwd);
+    try {
+        // Run all three queries concurrently
+        const [cachedNumstat, unstagedNumstat, statusRaw] = await Promise.all([
+            gitAsync(["diff", "--cached", "--numstat"], dir),
+            gitAsync(["diff", "--numstat"], dir),
+            gitAsync(["status", "--porcelain"], dir),
+        ]);
+        const result = [];
+        const seen = new Set();
+        const add = (info) => {
+            if (!seen.has(info.path)) {
+                seen.add(info.path);
+                result.push(info);
+            }
+        };
+        // 1. Staged files with numstat
+        for (const line of splitLines(cachedNumstat)) {
+            const [added, deleted, filePath] = line.split("\t");
+            if (!filePath)
+                continue;
+            const lines = added === "-" || deleted === "-"
+                ? undefined
+                : Number(added) + Number(deleted);
+            add({ path: filePath, changeType: "staged", linesChanged: lines });
+        }
+        // 2. Unstaged modifications with numstat
+        for (const line of splitLines(unstagedNumstat)) {
+            const [added, deleted, filePath] = line.split("\t");
+            if (!filePath)
+                continue;
+            const lines = added === "-" || deleted === "-"
+                ? undefined
+                : Number(added) + Number(deleted);
+            add({ path: filePath, changeType: "modified", linesChanged: lines });
+        }
+        // 3. Untracked / deleted from porcelain status
+        for (const line of splitLines(statusRaw)) {
+            const code = line.slice(0, 2);
+            const filePath = line.slice(3);
+            if (seen.has(filePath))
+                continue;
+            if (code.includes("?")) {
+                add({ path: filePath, changeType: "added" });
+            }
+            else if (code.includes("D")) {
+                add({ path: filePath, changeType: "deleted" });
+            }
+            else if (code.includes("A")) {
+                add({ path: filePath, changeType: "added" });
+            }
+            else {
+                add({ path: filePath, changeType: "modified" });
+            }
+        }
+        return result;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Ranks a file list so that recently-changed files appear first.
+ * Files present in `changedFiles` are placed at the front (in their
+ * original changedFiles order), followed by unchanged files in their
+ * original order.
+ */
+export function rankFilesByRelevance(files, changedFiles) {
+    const changedSet = new Set(changedFiles);
+    const changed = [];
+    const rest = [];
+    for (const f of files) {
+        if (changedSet.has(f)) {
+            changed.push(f);
+        }
+        else {
+            rest.push(f);
+        }
+    }
+    // Maintain changedFiles priority order within the changed group
+    const changedOrder = new Map(changedFiles.map((f, i) => [f, i]));
+    changed.sort((a, b) => (changedOrder.get(a) ?? 0) - (changedOrder.get(b) ?? 0));
+    return [...changed, ...rest];
+}

package/dist/resources/extensions/gsd/dispatch-guard.js

@@ -0,0 +1,76 @@
+// GSD Dispatch Guard — prevents out-of-order slice dispatch
+import { readFileSync } from "node:fs";
+import { resolveMilestoneFile } from "./paths.js";
+import { parseRoadmapSlices } from "./roadmap-slices.js";
+import { findMilestoneIds } from "./guided-flow.js";
+import { parseUnitId } from "./unit-id.js";
+const SLICE_DISPATCH_TYPES = new Set([
+    "research-slice",
+    "plan-slice",
+    "replan-slice",
+    "execute-task",
+    "complete-slice",
+]);
+/**
+ * Read a roadmap file from disk (working tree) rather than from a git branch.
+ *
+ * Prior implementation used `git show <branch>:<path>` which read committed
+ * state on a specific branch. This caused false-positive blockers when work
+ * was committed on a milestone/worktree branch but the integration branch
+ * (main) hadn't been updated yet — the guard would see prior slices as
+ * incomplete on main even though they were done in the working tree (#530).
+ *
+ * Reading from disk always reflects the latest state, regardless of which
+ * branch is checked out or whether changes have been committed.
+ */
+function readRoadmapFromDisk(base, milestoneId) {
+    try {
+        const absPath = resolveMilestoneFile(base, milestoneId, "ROADMAP");
+        if (!absPath)
+            return null;
+        return readFileSync(absPath, "utf-8").trim();
+    }
+    catch {
+        return null;
+    }
+}
+export function getPriorSliceCompletionBlocker(base, _mainBranch, unitType, unitId) {
+    if (!SLICE_DISPATCH_TYPES.has(unitType))
+        return null;
+    const { milestone: targetMid, slice: targetSid } = parseUnitId(unitId);
+    if (!targetMid || !targetSid)
+        return null;
+    // Use findMilestoneIds to respect custom queue order.
+    // Only check milestones that come BEFORE the target in queue order.
+    const allIds = findMilestoneIds(base);
+    const targetIdx = allIds.indexOf(targetMid);
+    if (targetIdx < 0)
+        return null;
+    const milestoneIds = allIds.slice(0, targetIdx + 1);
+    for (const mid of milestoneIds) {
+        // Skip parked milestones — they don't block dispatch of later milestones
+        const parkedFile = resolveMilestoneFile(base, mid, "PARKED");
+        if (parkedFile)
+            continue;
+        // Read from disk (working tree) — always has the latest state
+        const roadmapContent = readRoadmapFromDisk(base, mid);
+        if (!roadmapContent)
+            continue;
+        const slices = parseRoadmapSlices(roadmapContent);
+        if (mid !== targetMid) {
+            const incomplete = slices.find(slice => !slice.done);
+            if (incomplete) {
+                return `Cannot dispatch ${unitType} ${unitId}: earlier slice ${mid}/${incomplete.id} is not complete.`;
+            }
+            continue;
+        }
+        const targetIndex = slices.findIndex(slice => slice.id === targetSid);
+        if (targetIndex === -1)
+            return null;
+        const incomplete = slices.slice(0, targetIndex).find(slice => !slice.done);
+        if (incomplete) {
+            return `Cannot dispatch ${unitType} ${unitId}: earlier slice ${targetMid}/${incomplete.id} is not complete.`;
+        }
+    }
+    return null;
+}