gsd-pi 2.33.1 → 2.34.0-dev.6769913

package/dist/resources/extensions/gsd/{resource-version.ts → resource-version.js}

@@ -4,47 +4,42 @@
  * Staleness detection for managed GSD resources and utilities
  * for escaping stale worktree cwd after milestone teardown.
  */
-
 import { existsSync, readdirSync, unlinkSync } from "node:fs";
 import { loadJsonFileOrNull } from "./json-persistence.js";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { resolveProjectRoot } from "./worktree.js";
-
 // ─── Resource Staleness ───────────────────────────────────────────────────
-
 /**
  * Read the resource version (semver) from the managed-resources manifest.
  * Uses gsdVersion instead of syncedAt so that launching a second session
  * doesn't falsely trigger staleness (#804).
  */
-function isManifestWithVersion(data: unknown): data is { gsdVersion: string } {
-  return data !== null && typeof data === "object" && "gsdVersion" in data! && typeof (data as Record<string, unknown>).gsdVersion === "string";
+function isManifestWithVersion(data) {
+    return data !== null && typeof data === "object" && "gsdVersion" in data && typeof data.gsdVersion === "string";
 }
-
-export function readResourceVersion(): string | null {
-  const agentDir = process.env.GSD_CODING_AGENT_DIR || join(homedir(), ".gsd", "agent");
-  const manifestPath = join(agentDir, "managed-resources.json");
-  const manifest = loadJsonFileOrNull(manifestPath, isManifestWithVersion);
-  return manifest?.gsdVersion ?? null;
+export function readResourceVersion() {
+    const agentDir = process.env.GSD_CODING_AGENT_DIR || join(homedir(), ".gsd", "agent");
+    const manifestPath = join(agentDir, "managed-resources.json");
+    const manifest = loadJsonFileOrNull(manifestPath, isManifestWithVersion);
+    return manifest?.gsdVersion ?? null;
 }
-
 /**
  * Check if managed resources have been updated since session start.
  * Returns a warning message if stale, null otherwise.
  */
-export function checkResourcesStale(versionOnStart: string | null): string | null {
-  if (versionOnStart === null) return null;
-  const current = readResourceVersion();
-  if (current === null) return null;
-  if (current !== versionOnStart) {
-    return "GSD resources were updated since this session started. Restart gsd to load the new code.";
-  }
-  return null;
+export function checkResourcesStale(versionOnStart) {
+    if (versionOnStart === null)
+        return null;
+    const current = readResourceVersion();
+    if (current === null)
+        return null;
+    if (current !== versionOnStart) {
+        return "GSD resources were updated since this session started. Restart gsd to load the new code.";
+    }
+    return null;
 }
-
 // ─── Stale Worktree Escape ────────────────────────────────────────────────
-
 /**
  * Detect and escape a stale worktree cwd (#608).
  *
@@ -56,17 +51,18 @@ export function checkResourcesStale(versionOnStart: string | null): string | nul
  *
  * Returns the corrected base path.
  */
-export function escapeStaleWorktree(base: string): string {
-  const projectRoot = resolveProjectRoot(base);
-  if (projectRoot === base) return base;
-  try {
-    process.chdir(projectRoot);
-  } catch {
-    return base;
-  }
-  return projectRoot;
+export function escapeStaleWorktree(base) {
+    const projectRoot = resolveProjectRoot(base);
+    if (projectRoot === base)
+        return base;
+    try {
+        process.chdir(projectRoot);
+    }
+    catch {
+        return base;
+    }
+    return projectRoot;
 }
-
 /**
  * Clean stale runtime unit files for completed milestones.
  *
@@ -74,26 +70,27 @@ export function escapeStaleWorktree(base: string): string {
  * cause deriveState to resume the wrong milestone (#887). Removes files
  * for milestones that have a SUMMARY (fully complete).
  */
-export function cleanStaleRuntimeUnits(
-  gsdRootPath: string,
-  hasMilestoneSummary: (mid: string) => boolean,
-): number {
-  const runtimeUnitsDir = join(gsdRootPath, "runtime", "units");
-  if (!existsSync(runtimeUnitsDir)) return 0;
-
-  let cleaned = 0;
-  try {
-    for (const file of readdirSync(runtimeUnitsDir)) {
-      if (!file.endsWith(".json")) continue;
-      const midMatch = file.match(/(M\d+(?:-[a-z0-9]{6})?)/);
-      if (!midMatch) continue;
-      if (hasMilestoneSummary(midMatch[1])) {
-        try {
-          unlinkSync(join(runtimeUnitsDir, file));
-          cleaned++;
-        } catch { /* non-fatal */ }
-      }
+export function cleanStaleRuntimeUnits(gsdRootPath, hasMilestoneSummary) {
+    const runtimeUnitsDir = join(gsdRootPath, "runtime", "units");
+    if (!existsSync(runtimeUnitsDir))
+        return 0;
+    let cleaned = 0;
+    try {
+        for (const file of readdirSync(runtimeUnitsDir)) {
+            if (!file.endsWith(".json"))
+                continue;
+            const midMatch = file.match(/(M\d+(?:-[a-z0-9]{6})?)/);
+            if (!midMatch)
+                continue;
+            if (hasMilestoneSummary(midMatch[1])) {
+                try {
+                    unlinkSync(join(runtimeUnitsDir, file));
+                    cleaned++;
+                }
+                catch { /* non-fatal */ }
+            }
+        }
     }
-  } catch { /* non-fatal */ }
-  return cleaned;
+    catch { /* non-fatal */ }
+    return cleaned;
 }

package/dist/resources/extensions/gsd/roadmap-slices.js

@@ -0,0 +1,130 @@
+/**
+ * Expand dependency shorthand into individual slice IDs.
+ *
+ * Handles two common LLM-generated patterns that the roadmap parser
+ * previously treated as single literal IDs (silently blocking slices):
+ *
+ *   "S01-S04"  → ["S01", "S02", "S03", "S04"]  (range syntax)
+ *   "S01..S04" → ["S01", "S02", "S03", "S04"]  (dot-range syntax)
+ *
+ * Plain IDs ("S01", "S02") and empty strings pass through unchanged.
+ */
+export function expandDependencies(deps) {
+    const result = [];
+    for (const dep of deps) {
+        const trimmed = dep.trim();
+        if (!trimmed)
+            continue;
+        // Match range syntax: S01-S04 or S01..S04 (case-insensitive prefix)
+        const rangeMatch = trimmed.match(/^([A-Za-z]+)(\d+)(?:-|\.\.)+([A-Za-z]+)(\d+)$/);
+        if (rangeMatch) {
+            const prefixA = rangeMatch[1].toUpperCase();
+            const startNum = parseInt(rangeMatch[2], 10);
+            const prefixB = rangeMatch[3].toUpperCase();
+            const endNum = parseInt(rangeMatch[4], 10);
+            // Only expand when both prefixes match and range is valid
+            if (prefixA === prefixB && startNum <= endNum) {
+                const width = rangeMatch[2].length; // preserve zero-padding (S01 not S1)
+                for (let i = startNum; i <= endNum; i++) {
+                    result.push(`${prefixA}${String(i).padStart(width, "0")}`);
+                }
+                continue;
+            }
+        }
+        result.push(trimmed);
+    }
+    return result;
+}
+function extractSlicesSection(content) {
+    const headingMatch = /^## Slices\b.*$/m.exec(content);
+    if (!headingMatch || headingMatch.index == null)
+        return "";
+    const start = headingMatch.index + headingMatch[0].length;
+    const rest = content.slice(start).replace(/^\r?\n/, "");
+    const nextHeading = /^##\s+/m.exec(rest);
+    return (nextHeading ? rest.slice(0, nextHeading.index) : rest).trimEnd();
+}
+export function parseRoadmapSlices(content) {
+    const slicesSection = extractSlicesSection(content);
+    const slices = [];
+    if (!slicesSection) {
+        // Fallback: detect prose-style slice headers (## Slice S01: Title)
+        // when the LLM writes freeform prose instead of the ## Slices checklist.
+        // This prevents a permanent "No slice eligible" block (#807).
+        return parseProseSliceHeaders(content);
+    }
+    const checkboxItems = slicesSection.split("\n");
+    let currentSlice = null;
+    for (const line of checkboxItems) {
+        const cbMatch = line.match(/^\s*-\s+\[([ xX])\]\s+\*\*([\w.]+):\s+(.+?)\*\*\s*(.*)/);
+        if (cbMatch) {
+            if (currentSlice)
+                slices.push(currentSlice);
+            const done = cbMatch[1].toLowerCase() === "x";
+            const id = cbMatch[2];
+            const title = cbMatch[3];
+            const rest = cbMatch[4] ?? "";
+            const riskMatch = rest.match(/`risk:(\w+)`/);
+            const risk = (riskMatch ? riskMatch[1] : "low");
+            const depsMatch = rest.match(/`depends:\[([^\]]*)\]`/);
+            const depends = depsMatch && depsMatch[1].trim()
+                ? expandDependencies(depsMatch[1].split(",").map(s => s.trim()))
+                : [];
+            currentSlice = { id, title, risk, depends, done, demo: "" };
+            continue;
+        }
+        if (currentSlice && line.trim().startsWith(">")) {
+            currentSlice.demo = line.trim().replace(/^>\s*/, "").replace(/^After this:\s*/i, "");
+        }
+    }
+    if (currentSlice)
+        slices.push(currentSlice);
+    return slices;
+}
+/**
+ * Fallback parser for prose-style roadmaps where the LLM wrote
+ * slice headers instead of the machine-readable `## Slices` checklist.
+ * Extracts slice IDs and titles so auto-mode can at least identify
+ * slices and plan them.
+ *
+ * Handles these LLM-generated variants:
+ *   ## S01: Title           (H2, colon separator)
+ *   ### S01: Title          (H3)
+ *   #### S01: Title         (H4)
+ *   ## Slice S01: Title     (with "Slice" prefix)
+ *   ## S01 — Title          (em dash)
+ *   ## S01 – Title          (en dash)
+ *   ## S01 - Title          (hyphen)
+ *   ## S01. Title           (dot separator)
+ *   ## S01 Title            (space only, no separator)
+ *   ## **S01: Title**       (bold-wrapped)
+ *   ## **S01**: Title       (bold ID only)
+ *   ## S1: Title            (non-zero-padded ID)
+ */
+function parseProseSliceHeaders(content) {
+    const slices = [];
+    // Match H1–H4 headers containing S<digits> with optional "Slice" prefix and bold markers.
+    // Separator after the ID is flexible: colon, dash, em/en dash, dot, or just whitespace.
+    const headerPattern = /^#{1,4}\s+\*{0,2}(?:Slice\s+)?(S\d+)\*{0,2}[:\s.—–-]*\s*(.+)/gm;
+    let match;
+    while ((match = headerPattern.exec(content)) !== null) {
+        const id = match[1];
+        let title = match[2].trim().replace(/\*{1,2}$/g, "").trim(); // strip trailing bold markers
+        if (!title)
+            continue; // skip if we only matched the ID with no title
+        // Try to extract depends from prose: "Depends on: S01" or "**Depends on:** S01, S02"
+        const afterHeader = content.slice(match.index + match[0].length);
+        const nextHeader = afterHeader.search(/^#{1,4}\s/m);
+        const section = nextHeader !== -1 ? afterHeader.slice(0, nextHeader) : afterHeader.slice(0, 500);
+        const depsMatch = section.match(/\*{0,2}Depends\s+on:?\*{0,2}\s*(.+)/i);
+        let depends = [];
+        if (depsMatch) {
+            const rawDeps = depsMatch[1].replace(/none/i, "").trim();
+            if (rawDeps) {
+                depends = expandDependencies(rawDeps.split(/[,;]/).map(s => s.trim().replace(/[^A-Za-z0-9]/g, "")).filter(Boolean));
+            }
+        }
+        slices.push({ id, title, risk: "medium", depends, done: false, demo: "" });
+    }
+    return slices;
+}

package/dist/resources/extensions/gsd/routing-history.js

@@ -0,0 +1,210 @@
+// GSD Extension — Routing History (Adaptive Learning)
+// Tracks success/failure per tier per unit-type pattern to improve
+// classification accuracy over time.
+import { join } from "node:path";
+import { gsdRoot } from "./paths.js";
+import { loadJsonFile, saveJsonFile } from "./json-persistence.js";
+// ─── Constants ───────────────────────────────────────────────────────────────
+const HISTORY_FILE = "routing-history.json";
+const ROLLING_WINDOW = 50; // only consider last N entries per pattern
+const FAILURE_THRESHOLD = 0.20; // >20% failure rate triggers tier bump
+const FEEDBACK_WEIGHT = 2; // feedback signals count 2x vs automatic
+// ─── In-Memory State ─────────────────────────────────────────────────────────
+let history = null;
+let historyBasePath = "";
+// ─── Public API ──────────────────────────────────────────────────────────────
+/**
+ * Initialize routing history for a project.
+ */
+export function initRoutingHistory(base) {
+    historyBasePath = base;
+    history = loadHistory(base);
+}
+/**
+ * Reset routing history state.
+ */
+export function resetRoutingHistory() {
+    history = null;
+    historyBasePath = "";
+}
+/**
+ * Record the outcome of a unit dispatch.
+ *
+ * @param unitType  The unit type (e.g. "execute-task")
+ * @param tier      The tier that was used
+ * @param success   Whether the unit completed successfully
+ * @param tags      Optional tags from task metadata (e.g. ["docs", "test"])
+ */
+export function recordOutcome(unitType, tier, success, tags) {
+    if (!history)
+        return;
+    // Record for the base unit type
+    const basePattern = unitType;
+    ensurePattern(basePattern);
+    const outcome = history.patterns[basePattern][tier];
+    if (success)
+        outcome.success++;
+    else
+        outcome.fail++;
+    // Record for tag-specific patterns (e.g. "execute-task:docs")
+    if (tags && tags.length > 0) {
+        for (const tag of tags) {
+            const tagPattern = `${unitType}:${tag}`;
+            ensurePattern(tagPattern);
+            const tagOutcome = history.patterns[tagPattern][tier];
+            if (success)
+                tagOutcome.success++;
+            else
+                tagOutcome.fail++;
+        }
+    }
+    // Apply rolling window — cap total entries per tier per pattern
+    for (const pattern of Object.keys(history.patterns)) {
+        const p = history.patterns[pattern];
+        for (const t of ["light", "standard", "heavy"]) {
+            const total = p[t].success + p[t].fail;
+            if (total > ROLLING_WINDOW) {
+                const scale = ROLLING_WINDOW / total;
+                p[t].success = Math.round(p[t].success * scale);
+                p[t].fail = Math.round(p[t].fail * scale);
+            }
+        }
+    }
+    history.updatedAt = new Date().toISOString();
+    saveHistory(historyBasePath, history);
+}
+/**
+ * Record user feedback for the last completed unit.
+ */
+export function recordFeedback(unitType, unitId, tier, rating) {
+    if (!history)
+        return;
+    history.feedback.push({
+        unitType,
+        unitId,
+        tier,
+        rating,
+        timestamp: new Date().toISOString(),
+    });
+    // Cap feedback array at 200 entries
+    if (history.feedback.length > 200) {
+        history.feedback = history.feedback.slice(-200);
+    }
+    // Apply feedback as weighted outcome
+    const pattern = unitType;
+    ensurePattern(pattern);
+    if (rating === "over") {
+        // User says this could have used a simpler model → record as success at current tier
+        // and also as success at one tier lower (encourages more downgrading)
+        const lower = tierBelow(tier);
+        if (lower) {
+            const outcomes = history.patterns[pattern][lower];
+            outcomes.success += FEEDBACK_WEIGHT;
+        }
+    }
+    else if (rating === "under") {
+        // User says this needed a better model → record as failure at current tier
+        const outcomes = history.patterns[pattern][tier];
+        outcomes.fail += FEEDBACK_WEIGHT;
+    }
+    // "ok" = no adjustment needed
+    history.updatedAt = new Date().toISOString();
+    saveHistory(historyBasePath, history);
+}
+/**
+ * Get the recommended tier adjustment for a given pattern.
+ * Returns the tier to bump to if the failure rate exceeds threshold,
+ * or null if no adjustment is needed.
+ */
+export function getAdaptiveTierAdjustment(unitType, currentTier, tags) {
+    if (!history)
+        return null;
+    // Check tag-specific patterns first (more specific)
+    if (tags && tags.length > 0) {
+        for (const tag of tags) {
+            const tagPattern = `${unitType}:${tag}`;
+            const adjustment = checkPatternFailureRate(tagPattern, currentTier);
+            if (adjustment)
+                return adjustment;
+        }
+    }
+    // Fall back to base pattern
+    return checkPatternFailureRate(unitType, currentTier);
+}
+/**
+ * Clear all routing history (user-triggered reset).
+ */
+export function clearRoutingHistory(base) {
+    history = createEmptyHistory();
+    saveHistory(base, history);
+}
+/**
+ * Get current history data (for display/debugging).
+ */
+export function getRoutingHistory() {
+    return history;
+}
+// ─── Internal ────────────────────────────────────────────────────────────────
+function checkPatternFailureRate(pattern, tier) {
+    if (!history?.patterns[pattern])
+        return null;
+    const outcomes = history.patterns[pattern][tier];
+    const total = outcomes.success + outcomes.fail;
+    if (total < 3)
+        return null; // Not enough data
+    const failureRate = outcomes.fail / total;
+    if (failureRate > FAILURE_THRESHOLD) {
+        // Bump to next tier
+        return tierAbove(tier);
+    }
+    return null;
+}
+function tierAbove(tier) {
+    switch (tier) {
+        case "light": return "standard";
+        case "standard": return "heavy";
+        case "heavy": return null;
+    }
+}
+function tierBelow(tier) {
+    switch (tier) {
+        case "light": return null;
+        case "standard": return "light";
+        case "heavy": return "standard";
+    }
+}
+function ensurePattern(pattern) {
+    if (!history)
+        return;
+    if (!history.patterns[pattern]) {
+        history.patterns[pattern] = {
+            light: { success: 0, fail: 0 },
+            standard: { success: 0, fail: 0 },
+            heavy: { success: 0, fail: 0 },
+        };
+    }
+}
+function createEmptyHistory() {
+    return {
+        version: 1,
+        patterns: {},
+        feedback: [],
+        updatedAt: new Date().toISOString(),
+    };
+}
+function historyPath(base) {
+    return join(gsdRoot(base), HISTORY_FILE);
+}
+function isRoutingHistoryData(data) {
+    return (typeof data === "object" &&
+        data !== null &&
+        data.version === 1 &&
+        typeof data.patterns === "object" &&
+        data.patterns !== null);
+}
+function loadHistory(base) {
+    return loadJsonFile(historyPath(base), isRoutingHistoryData, createEmptyHistory);
+}
+function saveHistory(base, data) {
+    saveJsonFile(historyPath(base), data);
+}

package/dist/resources/extensions/gsd/safe-fs.js

@@ -0,0 +1,52 @@
+import { existsSync, mkdirSync, cpSync } from "node:fs";
+import { dirname } from "node:path";
+/**
+ * Safely creates a directory. Returns true if successful, false on error.
+ * Logs to stderr when GSD_DEBUG is set.
+ */
+export function safeMkdir(dirPath) {
+    try {
+        mkdirSync(dirPath, { recursive: true });
+        return true;
+    }
+    catch (err) {
+        if (process.env.GSD_DEBUG)
+            console.error(`[gsd] mkdir failed: ${dirPath}`, err);
+        return false;
+    }
+}
+/**
+ * Safely copies src to dst. Returns true if successful, false if src doesn't exist or copy fails.
+ * Logs to stderr when GSD_DEBUG is set.
+ */
+export function safeCopy(src, dst, opts) {
+    if (!existsSync(src))
+        return false;
+    try {
+        cpSync(src, dst, opts);
+        return true;
+    }
+    catch (err) {
+        if (process.env.GSD_DEBUG)
+            console.error(`[gsd] copy failed: ${src} → ${dst}`, err);
+        return false;
+    }
+}
+/**
+ * Safely copies a directory recursively, creating the parent of dst if needed.
+ * Returns true if successful.
+ */
+export function safeCopyRecursive(src, dst, opts) {
+    if (!existsSync(src))
+        return false;
+    try {
+        mkdirSync(dirname(dst), { recursive: true });
+        cpSync(src, dst, { ...opts, recursive: true });
+        return true;
+    }
+    catch (err) {
+        if (process.env.GSD_DEBUG)
+            console.error(`[gsd] recursive copy failed: ${src} → ${dst}`, err);
+        return false;
+    }
+}