gsd-pi 2.33.0 → 2.33.1-dev.235d83a

package/dist/resources/extensions/gsd/structured-data-formatter.js

@@ -0,0 +1,97 @@
+/**
+ * Structured Data Formatter — compact notation for prompt injection.
+ *
+ * Converts GSD data structures into a token-efficient format that removes
+ * markdown table overhead, redundant labels, and formatting while remaining
+ * perfectly readable by LLMs.
+ *
+ * Format rules:
+ * - No table pipes, dashes, or header rows
+ * - Use indentation (2 spaces) for structure instead of delimiters
+ * - Omit field names when the pattern is clear from a header
+ * - Use single-line entries for simple records
+ * - Use multi-line with indentation for complex records
+ */
+// ---------------------------------------------------------------------------
+// Decisions
+// ---------------------------------------------------------------------------
+/** Compact format for a single decision record (pipe-separated, no padding). */
+export function formatDecisionCompact(decision) {
+    return [
+        decision.id,
+        decision.when_context,
+        decision.scope,
+        decision.decision,
+        decision.choice,
+        decision.rationale,
+        decision.revisable,
+    ].join(" | ");
+}
+/** Format multiple decisions in compact notation with a Fields header. */
+export function formatDecisionsCompact(decisions) {
+    if (decisions.length === 0) {
+        return "# Decisions (compact)\n(none)";
+    }
+    const header = "# Decisions (compact)\nFields: id | when | scope | decision | choice | rationale | revisable";
+    const lines = decisions.map(formatDecisionCompact);
+    return `${header}\n\n${lines.join("\n")}`;
+}
+// ---------------------------------------------------------------------------
+// Requirements
+// ---------------------------------------------------------------------------
+/** Compact format for a single requirement record (multi-line). */
+export function formatRequirementCompact(req) {
+    const lines = [];
+    lines.push(`${req.id} [${req.class}] (${req.status}) owner:${req.primary_owner}`);
+    lines.push(`  ${req.description}`);
+    lines.push(`  why: ${req.why}`);
+    lines.push(`  validate: ${req.validation}`);
+    return lines.join("\n");
+}
+/** Format multiple requirements in compact notation. */
+export function formatRequirementsCompact(requirements) {
+    if (requirements.length === 0) {
+        return "# Requirements (compact)\n(none)";
+    }
+    const header = "# Requirements (compact)";
+    const blocks = requirements.map(formatRequirementCompact);
+    return `${header}\n\n${blocks.join("\n\n")}`;
+}
+// ---------------------------------------------------------------------------
+// Task Plans
+// ---------------------------------------------------------------------------
+/** Compact format for task plan entries. */
+export function formatTaskPlanCompact(tasks) {
+    if (tasks.length === 0) {
+        return "# Tasks (compact)\n(none)";
+    }
+    const header = "# Tasks (compact)";
+    const blocks = tasks.map((t) => {
+        const check = t.done ? "x" : " ";
+        const lines = [];
+        lines.push(`${t.id} [${check}] ${t.title} (${t.estimate})`);
+        if (t.files && t.files.length > 0) {
+            lines.push(`  files: ${t.files.join(", ")}`);
+        }
+        if (t.verify) {
+            lines.push(`  verify: ${t.verify}`);
+        }
+        lines.push(`  ${t.description}`);
+        return lines.join("\n");
+    });
+    return `${header}\n\n${blocks.join("\n\n")}`;
+}
+// ---------------------------------------------------------------------------
+// Savings measurement
+// ---------------------------------------------------------------------------
+/**
+ * Measure the token savings of compact format vs markdown format.
+ * Returns savings as a percentage (0-100).
+ * A positive number means compact is smaller (saves tokens).
+ */
+export function measureSavings(compactContent, markdownContent) {
+    if (markdownContent.length === 0)
+        return 0;
+    const saved = markdownContent.length - compactContent.length;
+    return (saved / markdownContent.length) * 100;
+}

package/dist/resources/extensions/gsd/summary-distiller.js

@@ -0,0 +1,212 @@
+/**
+ * Summary distiller — extracts essential structured data from SUMMARY.md files,
+ * dropping verbose prose to save context budget.
+ */
+// ─── Frontmatter parsing ─────────────────────────────────────────────────────
+function parseFrontmatter(raw) {
+    const result = {
+        id: "",
+        provides: [],
+        requires: [],
+        key_files: [],
+        key_decisions: [],
+        patterns_established: [],
+    };
+    // Extract frontmatter block between --- markers
+    const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!fmMatch)
+        return result;
+    const fmBlock = fmMatch[1];
+    const lines = fmBlock.split(/\r?\n/);
+    let currentKey = null;
+    for (const line of lines) {
+        // Scalar value: key: value
+        const scalarMatch = line.match(/^(\w[\w_]*):\s*(.+)$/);
+        if (scalarMatch) {
+            const [, key, value] = scalarMatch;
+            currentKey = key;
+            setScalar(result, key, value.trim());
+            continue;
+        }
+        // Array-start key with empty value: key:\n  or key: []\n
+        const arrayStartMatch = line.match(/^(\w[\w_]*):\s*(\[\])?\s*$/);
+        if (arrayStartMatch) {
+            currentKey = arrayStartMatch[1];
+            continue;
+        }
+        // Array item:   - value
+        const itemMatch = line.match(/^\s+-\s+(.+)$/);
+        if (itemMatch && currentKey) {
+            pushItem(result, currentKey, itemMatch[1].trim());
+            continue;
+        }
+    }
+    return result;
+}
+function setScalar(fm, key, value) {
+    if (key === "id")
+        fm.id = value;
+}
+function pushItem(fm, key, value) {
+    switch (key) {
+        case "provides":
+            fm.provides.push(value);
+            break;
+        case "requires":
+            fm.requires.push(value);
+            break;
+        case "key_files":
+            fm.key_files.push(value);
+            break;
+        case "key_decisions":
+            fm.key_decisions.push(value);
+            break;
+        case "patterns_established":
+            fm.patterns_established.push(value);
+            break;
+    }
+}
+// ─── Body parsing ────────────────────────────────────────────────────────────
+function extractTitleAndOneLiner(body) {
+    const lines = body.split(/\r?\n/);
+    let titleId = "";
+    let oneLiner = "";
+    let foundTitle = false;
+    for (const line of lines) {
+        const titleMatch = line.match(/^#\s+(\S+):\s*(.*)$/);
+        if (titleMatch && !foundTitle) {
+            titleId = titleMatch[1];
+            // If the title line itself has text after "S01: ", use that as a fallback
+            if (titleMatch[2].trim()) {
+                oneLiner = titleMatch[2].trim();
+            }
+            foundTitle = true;
+            continue;
+        }
+        // First non-empty line after the title is the one-liner
+        if (foundTitle && !oneLiner && line.trim() && !line.startsWith("#")) {
+            oneLiner = line.trim();
+            break;
+        }
+    }
+    return { id: titleId, oneLiner };
+}
+function getBodyAfterFrontmatter(raw) {
+    const fmMatch = raw.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
+    if (fmMatch) {
+        return raw.slice(fmMatch[0].length);
+    }
+    return raw;
+}
+// ─── Public API ──────────────────────────────────────────────────────────────
+/**
+ * Distill a single SUMMARY.md content string into a compact structured block.
+ */
+export function distillSingle(summary) {
+    const fm = parseFrontmatter(summary);
+    const body = getBodyAfterFrontmatter(summary);
+    const { id: titleId, oneLiner } = extractTitleAndOneLiner(body);
+    const id = fm.id || titleId || "???";
+    return formatEntry({
+        id,
+        oneLiner,
+        provides: fm.provides,
+        requires: fm.requires,
+        key_files: fm.key_files,
+        key_decisions: fm.key_decisions,
+        patterns: fm.patterns_established,
+    });
+}
+function formatEntry(entry) {
+    return formatEntryWithDropLevel(entry, 0);
+}
+/**
+ * Format an entry, progressively dropping fields based on dropLevel:
+ *   0 = full output
+ *   1 = drop patterns
+ *   2 = drop patterns + key_decisions
+ *   3 = drop patterns + key_decisions + key_files
+ */
+function formatEntryWithDropLevel(entry, dropLevel) {
+    const lines = [];
+    lines.push(`## ${entry.id}: ${entry.oneLiner}`);
+    if (entry.provides.length > 0) {
+        lines.push(`provides: ${entry.provides.join(", ")}`);
+    }
+    if (entry.requires.length > 0) {
+        lines.push(`requires: ${entry.requires.join(", ")}`);
+    }
+    if (dropLevel < 3 && entry.key_files.length > 0) {
+        lines.push(`key_files: ${entry.key_files.join(", ")}`);
+    }
+    if (dropLevel < 2 && entry.key_decisions.length > 0) {
+        lines.push(`key_decisions: ${entry.key_decisions.join(", ")}`);
+    }
+    if (dropLevel < 1 && entry.patterns.length > 0) {
+        lines.push(`patterns: ${entry.patterns.join(", ")}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Distill multiple SUMMARY.md contents into a budget-constrained output.
+ */
+export function distillSummaries(summaries, budgetChars) {
+    const originalChars = summaries.reduce((sum, s) => sum + s.length, 0);
+    if (summaries.length === 0) {
+        return {
+            content: "",
+            summaryCount: 0,
+            savingsPercent: 0,
+            originalChars: 0,
+            distilledChars: 0,
+        };
+    }
+    // Parse all entries up front
+    const entries = summaries.map((summary) => {
+        const fm = parseFrontmatter(summary);
+        const body = getBodyAfterFrontmatter(summary);
+        const { id: titleId, oneLiner } = extractTitleAndOneLiner(body);
+        return {
+            id: fm.id || titleId || "???",
+            oneLiner,
+            provides: fm.provides,
+            requires: fm.requires,
+            key_files: fm.key_files,
+            key_decisions: fm.key_decisions,
+            patterns: fm.patterns_established,
+        };
+    });
+    // Try progressively more aggressive dropping until it fits
+    for (let dropLevel = 0; dropLevel <= 3; dropLevel++) {
+        const blocks = entries.map((e) => formatEntryWithDropLevel(e, dropLevel));
+        const content = blocks.join("\n\n");
+        if (content.length <= budgetChars) {
+            const distilledChars = content.length;
+            return {
+                content,
+                summaryCount: summaries.length,
+                savingsPercent: originalChars > 0
+                    ? Math.round((1 - distilledChars / originalChars) * 100)
+                    : 0,
+                originalChars,
+                distilledChars,
+            };
+        }
+    }
+    // Even at max drop level it doesn't fit — truncate
+    const blocks = entries.map((e) => formatEntryWithDropLevel(e, 3));
+    let content = blocks.join("\n\n");
+    if (content.length > budgetChars) {
+        content = content.slice(0, Math.max(0, budgetChars - 15)) + "\n[...truncated]";
+    }
+    const distilledChars = content.length;
+    return {
+        content,
+        summaryCount: summaries.length,
+        savingsPercent: originalChars > 0
+            ? Math.round((1 - distilledChars / originalChars) * 100)
+            : 0,
+        originalChars,
+        distilledChars,
+    };
+}

package/dist/resources/extensions/gsd/token-counter.js

@@ -0,0 +1,54 @@
+const CHARS_PER_TOKEN_BY_PROVIDER = {
+    anthropic: 3.5,
+    openai: 4.0,
+    google: 4.0,
+    mistral: 3.8,
+    bedrock: 3.5,
+    unknown: 4.0,
+};
+let encoder = null;
+let encoderFailed = false;
+async function getEncoder() {
+    if (encoder)
+        return encoder;
+    if (encoderFailed)
+        return null;
+    try {
+        // @ts-ignore — tiktoken may not have type declarations in extensions tsconfig
+        const tiktoken = await import("tiktoken");
+        encoder = tiktoken.encoding_for_model("gpt-4o");
+        return encoder;
+    }
+    catch {
+        encoderFailed = true;
+        return null;
+    }
+}
+export async function countTokens(text) {
+    const enc = await getEncoder();
+    if (enc) {
+        const tokens = enc.encode(text);
+        return tokens.length;
+    }
+    return Math.ceil(text.length / 4);
+}
+export function countTokensSync(text) {
+    if (encoder) {
+        return encoder.encode(text).length;
+    }
+    return Math.ceil(text.length / 4);
+}
+export async function initTokenCounter() {
+    const enc = await getEncoder();
+    return enc !== null;
+}
+export function isAccurateCountingAvailable() {
+    return encoder !== null;
+}
+export function getCharsPerToken(provider) {
+    return CHARS_PER_TOKEN_BY_PROVIDER[provider] ?? CHARS_PER_TOKEN_BY_PROVIDER.unknown;
+}
+export function estimateTokensForProvider(text, provider) {
+    const ratio = getCharsPerToken(provider);
+    return Math.ceil(text.length / ratio);
+}

package/dist/resources/extensions/gsd/triage-resolution.js

@@ -0,0 +1,217 @@
+/**
+ * GSD Triage Resolution — Execute triage classifications
+ *
+ * Provides resolution executors for each capture classification type:
+ *
+ * - inject: appends a new task to the current slice plan
+ * - replan: writes REPLAN-TRIGGER.md so next dispatchNextUnit enters replanning-slice
+ * - defer/note: query helpers for loading deferred/replan captures
+ *
+ * Also provides detectFileOverlap() for surfacing downstream impact on quick tasks.
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { gsdRoot } from "./paths.js";
+import { loadAllCaptures, loadActionableCaptures, markCaptureExecuted, } from "./captures.js";
+// ─── Resolution Executors ─────────────────────────────────────────────────────
+/**
+ * Inject a new task into the current slice plan.
+ * Reads the plan, finds the highest task ID, appends a new task entry.
+ * Returns the new task ID, or null if injection failed.
+ */
+export function executeInject(basePath, mid, sid, capture) {
+    try {
+        // Resolve the plan file path
+        const planPath = join(gsdRoot(basePath), "milestones", mid, "slices", sid, `${sid}-PLAN.md`);
+        if (!existsSync(planPath))
+            return null;
+        const content = readFileSync(planPath, "utf-8");
+        // Find the highest existing task ID
+        const taskMatches = [...content.matchAll(/- \[[ x]\] \*\*T(\d+):/g)];
+        if (taskMatches.length === 0)
+            return null;
+        const maxId = Math.max(...taskMatches.map(m => parseInt(m[1], 10)));
+        const newId = `T${String(maxId + 1).padStart(2, "0")}`;
+        // Build the new task entry
+        const newTask = [
+            `- [ ] **${newId}: ${capture.text}** \`est:30m\``,
+            `  - Why: Injected from capture ${capture.id} during triage`,
+            `  - Do: ${capture.text}`,
+            `  - Done when: Capture intent fulfilled`,
+        ].join("\n");
+        // Find the last task entry and append after it
+        // Look for the "## Files Likely Touched" section as the boundary
+        const filesSection = content.indexOf("## Files Likely Touched");
+        if (filesSection !== -1) {
+            const updated = content.slice(0, filesSection) + newTask + "\n\n" + content.slice(filesSection);
+            writeFileSync(planPath, updated, "utf-8");
+        }
+        else {
+            // No Files section — append at end
+            writeFileSync(planPath, content.trimEnd() + "\n\n" + newTask + "\n", "utf-8");
+        }
+        return newId;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Trigger replanning by writing a REPLAN-TRIGGER.md marker file.
+ * The existing state.ts derivation detects this and sets phase to "replanning-slice".
+ * Returns true if the trigger was written successfully.
+ */
+export function executeReplan(basePath, mid, sid, capture) {
+    try {
+        const triggerPath = join(basePath, ".gsd", "milestones", mid, "slices", sid, `${sid}-REPLAN-TRIGGER.md`);
+        const content = [
+            `# Replan Trigger`,
+            ``,
+            `**Source:** Capture ${capture.id}`,
+            `**Capture:** ${capture.text}`,
+            `**Rationale:** ${capture.rationale ?? "User-initiated replan via capture triage"}`,
+            `**Triggered:** ${new Date().toISOString()}`,
+            ``,
+            `This file was created by the triage pipeline. The next dispatch cycle`,
+            `will detect it and enter the replanning-slice phase.`,
+        ].join("\n");
+        writeFileSync(triggerPath, content, "utf-8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ─── File Overlap Detection ───────────────────────────────────────────────────
+/**
+ * Detect file overlap between a capture's affected files and planned tasks.
+ *
+ * Parses the slice plan for task file references and returns task IDs
+ * whose files overlap with the capture's affected files.
+ *
+ * @param affectedFiles - Files the capture would touch
+ * @param planContent - Content of the slice plan.md
+ * @returns Array of task IDs (e.g., ["T03", "T04"]) whose files overlap
+ */
+export function detectFileOverlap(affectedFiles, planContent) {
+    if (!affectedFiles || affectedFiles.length === 0)
+        return [];
+    const overlappingTasks = [];
+    // Normalize affected files for comparison
+    const normalizedAffected = new Set(affectedFiles.map(f => f.replace(/^\.\//, "").toLowerCase()));
+    // Parse plan for incomplete tasks and their file references
+    const taskPattern = /- \[ \] \*\*(T\d+):[^*]*\*\*/g;
+    const tasks = [...planContent.matchAll(taskPattern)];
+    for (const taskMatch of tasks) {
+        const taskId = taskMatch[1];
+        const taskStart = taskMatch.index;
+        // Find the end of this task (next task or end of section)
+        const nextTask = planContent.indexOf("- [", taskStart + 1);
+        const sectionEnd = planContent.indexOf("##", taskStart + 1);
+        const taskEnd = Math.min(nextTask === -1 ? planContent.length : nextTask, sectionEnd === -1 ? planContent.length : sectionEnd);
+        const taskContent = planContent.slice(taskStart, taskEnd);
+        // Extract file references — look for backtick-quoted paths
+        const fileRefs = [...taskContent.matchAll(/`([^`]+\.[a-z]+)`/g)]
+            .map(m => m[1].replace(/^\.\//, "").toLowerCase());
+        // Check for overlap
+        const hasOverlap = fileRefs.some(f => normalizedAffected.has(f));
+        if (hasOverlap) {
+            overlappingTasks.push(taskId);
+        }
+    }
+    return overlappingTasks;
+}
+/**
+ * Load deferred captures (classification === "defer") for injection into
+ * reassess-roadmap prompts.
+ */
+export function loadDeferredCaptures(basePath) {
+    return loadAllCaptures(basePath).filter(c => c.classification === "defer");
+}
+/**
+ * Load replan-triggering captures for injection into replan-slice prompts.
+ */
+export function loadReplanCaptures(basePath) {
+    return loadAllCaptures(basePath).filter(c => c.classification === "replan");
+}
+/**
+ * Build a quick-task execution prompt from a capture.
+ */
+export function buildQuickTaskPrompt(capture) {
+    return [
+        `You are executing a quick one-off task captured during a GSD auto-mode session.`,
+        ``,
+        `## Quick Task`,
+        ``,
+        `**Capture ID:** ${capture.id}`,
+        `**Task:** ${capture.text}`,
+        ``,
+        `## Instructions`,
+        ``,
+        `1. Execute this task as a small, self-contained change.`,
+        `2. Do NOT modify any \`.gsd/\` plan files — this is a one-off, not a planned task.`,
+        `3. Commit your changes with a descriptive message.`,
+        `4. Keep changes minimal and focused on the capture text.`,
+        `5. When done, say: "Quick task complete."`,
+    ].join("\n");
+}
+/**
+ * Execute pending triage resolutions.
+ *
+ * Called after a triage-captures unit completes. Reads CAPTURES.md for
+ * resolved captures that have actionable classifications (inject, replan,
+ * quick-task) but haven't been executed yet, then:
+ *
+ * - inject: calls executeInject() to add a task to the current slice plan
+ * - replan: calls executeReplan() to write the REPLAN-TRIGGER.md marker
+ * - quick-task: collects for dispatch (caller handles dispatching quick-task units)
+ *
+ * Each capture is marked as executed after its resolution action succeeds,
+ * preventing double-execution on retries or restarts.
+ */
+export function executeTriageResolutions(basePath, mid, sid) {
+    const result = {
+        injected: 0,
+        replanned: 0,
+        quickTasks: [],
+        actions: [],
+    };
+    const actionable = loadActionableCaptures(basePath);
+    if (actionable.length === 0)
+        return result;
+    for (const capture of actionable) {
+        switch (capture.classification) {
+            case "inject": {
+                const newTaskId = executeInject(basePath, mid, sid, capture);
+                if (newTaskId) {
+                    markCaptureExecuted(basePath, capture.id);
+                    result.injected++;
+                    result.actions.push(`Injected ${newTaskId} from ${capture.id}: "${capture.text}"`);
+                }
+                else {
+                    result.actions.push(`Failed to inject ${capture.id}: "${capture.text}" (no plan file or parse error)`);
+                }
+                break;
+            }
+            case "replan": {
+                const success = executeReplan(basePath, mid, sid, capture);
+                if (success) {
+                    markCaptureExecuted(basePath, capture.id);
+                    result.replanned++;
+                    result.actions.push(`Replan triggered from ${capture.id}: "${capture.text}"`);
+                }
+                else {
+                    result.actions.push(`Failed to trigger replan from ${capture.id}: "${capture.text}"`);
+                }
+                break;
+            }
+            case "quick-task": {
+                // Quick-tasks are collected for dispatch, not executed inline
+                result.quickTasks.push(capture);
+                result.actions.push(`Quick-task queued from ${capture.id}: "${capture.text}"`);
+                break;
+            }
+        }
+    }
+    return result;
+}