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

package/dist/resources/extensions/gsd/prompt-compressor.js

@@ -0,0 +1,393 @@
+/**
+ * Prompt Compressor — deterministic text compression for context reduction.
+ *
+ * Applies a series of lossless and near-lossless transformations to reduce
+ * token count while preserving semantic meaning. No LLM calls, no external
+ * dependencies. Sub-millisecond for typical prompt sizes.
+ *
+ * Compression techniques (applied in order):
+ * 1. Redundant whitespace normalization
+ * 2. Markdown formatting reduction (collapse verbose tables, lists)
+ * 3. Common phrase abbreviation
+ * 4. Repeated pattern deduplication
+ * 5. Low-information content removal (empty sections, boilerplate)
+ */
+// ─── Phrase Abbreviation Map ────────────────────────────────────────────────
+/**
+ * Build a regex that matches a verbose phrase even when split across lines.
+ * Whitespace between words is matched with \s+ to handle line wrapping.
+ */
+function phraseRegex(phrase) {
+    const words = phrase.split(/\s+/);
+    const pattern = `\\b${words.join("\\s+")}\\b`;
+    return new RegExp(pattern, "gi");
+}
+const VERBOSE_PHRASES = [
+    [phraseRegex("In order to"), "To"],
+    [phraseRegex("It is important to note that"), "Note:"],
+    [phraseRegex("As mentioned previously"), "(see above)"],
+    [phraseRegex("The following"), "These"],
+    [phraseRegex("In addition to"), "Also,"],
+    [phraseRegex("Due to the fact that"), "Because"],
+    [phraseRegex("At this point in time"), "Now"],
+    [phraseRegex("For the purpose of"), "For"],
+    [phraseRegex("In the event that"), "If"],
+    [phraseRegex("With regard to"), "Re:"],
+    [phraseRegex("Prior to"), "Before"],
+    [phraseRegex("Subsequent to"), "After"],
+    [phraseRegex("In accordance with"), "Per"],
+    [phraseRegex("A number of"), "Several"],
+    [phraseRegex("In the case of"), "For"],
+    [phraseRegex("On the basis of"), "Based on"],
+];
+function extractCodeBlocks(content) {
+    const blocks = new Map();
+    let counter = 0;
+    const text = content.replace(/```[\s\S]*?```/g, (match) => {
+        const placeholder = `\x00CODEBLOCK_${counter++}\x00`;
+        blocks.set(placeholder, match);
+        return placeholder;
+    });
+    return { text, blocks };
+}
+function restoreCodeBlocks(text, blocks) {
+    let result = text;
+    for (const [placeholder, block] of blocks) {
+        result = result.replace(placeholder, block);
+    }
+    return result;
+}
+// ─── Light Transformations ──────────────────────────────────────────────────
+function normalizeWhitespace(content) {
+    // Collapse 3+ consecutive blank lines to 2
+    let result = content.replace(/(\n\s*){3,}\n/g, "\n\n");
+    // Trim trailing whitespace on every line
+    result = result.replace(/[ \t]+$/gm, "");
+    return result;
+}
+function removeMarkdownComments(content) {
+    return content.replace(/<!--[\s\S]*?-->/g, "");
+}
+function removeHorizontalRules(content) {
+    // Remove horizontal rules (---, ***, ___) that stand alone on a line
+    return content.replace(/^\s*[-*_]{3,}\s*$/gm, "");
+}
+function collapseEmptyListItems(content) {
+    // Collapse repeated empty list items (- \n- \n- \n) into one
+    return content.replace(/(^[ \t]*[-*+]\s*$\n){2,}/gm, "$1");
+}
+function applyLightTransformations(content) {
+    let count = 0;
+    let result = content;
+    const after1 = normalizeWhitespace(result);
+    if (after1 !== result)
+        count++;
+    result = after1;
+    const after2 = removeMarkdownComments(result);
+    if (after2 !== result)
+        count++;
+    result = after2;
+    const after3 = removeHorizontalRules(result);
+    if (after3 !== result)
+        count++;
+    result = after3;
+    const after4 = collapseEmptyListItems(result);
+    if (after4 !== result)
+        count++;
+    result = after4;
+    return { content: result, count };
+}
+// ─── Moderate Transformations ───────────────────────────────────────────────
+function abbreviateVerbosePhrases(content) {
+    let count = 0;
+    let result = content;
+    for (const [pattern, replacement] of VERBOSE_PHRASES) {
+        const after = result.replace(pattern, replacement);
+        if (after !== result)
+            count++;
+        result = after;
+    }
+    return { content: result, count };
+}
+function removeBoilerplateLines(content) {
+    const lines = content.split("\n");
+    const filtered = lines.filter((line) => {
+        const trimmed = line.trim();
+        // Remove lines that are just N/A, (none), (empty), (not applicable)
+        if (/^(?:N\/A|\(none\)|\(empty\)|\(not applicable\))$/i.test(trimmed)) {
+            return false;
+        }
+        return true;
+    });
+    return filtered.join("\n");
+}
+function deduplicateConsecutiveLines(content) {
+    const lines = content.split("\n");
+    const result = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (i === 0 || lines[i] !== lines[i - 1] || lines[i].trim() === "") {
+            result.push(lines[i]);
+        }
+    }
+    return result.join("\n");
+}
+function collapseTableFormatting(content) {
+    // Remove excessive padding in markdown table cells
+    // Matches table rows like |  cell  |  cell  | and collapses to | cell | cell |
+    return content.replace(/\|[ \t]{2,}([^|\n]*?)[ \t]{2,}\|/g, (_, cellContent) => {
+        return `| ${cellContent.trim()} |`;
+    });
+}
+function applyModerateTransformations(content) {
+    let count = 0;
+    let result = content;
+    const phraseResult = abbreviateVerbosePhrases(result);
+    count += phraseResult.count;
+    result = phraseResult.content;
+    const after1 = removeBoilerplateLines(result);
+    if (after1 !== result)
+        count++;
+    result = after1;
+    const after2 = deduplicateConsecutiveLines(result);
+    if (after2 !== result)
+        count++;
+    result = after2;
+    const after3 = collapseTableFormatting(result);
+    if (after3 !== result)
+        count++;
+    result = after3;
+    return { content: result, count };
+}
+// ─── Aggressive Transformations ─────────────────────────────────────────────
+function removeMarkdownEmphasis(content) {
+    // Bold: **text** or __text__
+    let result = content.replace(/\*\*(.+?)\*\*/g, "$1");
+    result = result.replace(/__(.+?)__/g, "$1");
+    // Italic: *text* or _text_ (single, not inside words)
+    result = result.replace(/(?<!\w)\*([^*\n]+?)\*(?!\w)/g, "$1");
+    result = result.replace(/(?<!\w)_([^_\n]+?)_(?!\w)/g, "$1");
+    return result;
+}
+function removeMarkdownLinks(content) {
+    // [text](url) → text
+    return content.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+}
+function truncateLongLines(content) {
+    const lines = content.split("\n");
+    const result = lines.map((line) => {
+        if (line.length <= 300)
+            return line;
+        // Find a sentence boundary (. ! ?) near the 300 char mark
+        const truncateZone = line.slice(0, 300);
+        const lastSentenceEnd = Math.max(truncateZone.lastIndexOf(". "), truncateZone.lastIndexOf("! "), truncateZone.lastIndexOf("? "));
+        if (lastSentenceEnd > 150) {
+            return line.slice(0, lastSentenceEnd + 1);
+        }
+        // Fallback: cut at last space before 300
+        const lastSpace = truncateZone.lastIndexOf(" ");
+        if (lastSpace > 150) {
+            return line.slice(0, lastSpace);
+        }
+        return truncateZone;
+    });
+    return result.join("\n");
+}
+function removeBulletMarkers(content) {
+    // Remove bullet markers: - , * , + , numbered (1. 2. etc)
+    return content.replace(/^[ \t]*(?:[-*+]|\d+\.)\s+/gm, "");
+}
+function removeBlockquoteMarkers(content) {
+    return content.replace(/^[ \t]*>+\s?/gm, "");
+}
+function deduplicateStructuralPatterns(content) {
+    // Deduplicate consecutive lines that match the same "Key: value" pattern
+    const lines = content.split("\n");
+    const result = [];
+    const seen = new Set();
+    let lastWasStructural = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Detect structural patterns: "Key: value"
+        const structMatch = trimmed.match(/^(\w[\w\s]*?):\s+(.+)$/);
+        if (structMatch) {
+            if (seen.has(trimmed)) {
+                lastWasStructural = true;
+                continue;
+            }
+            seen.add(trimmed);
+            lastWasStructural = true;
+        }
+        else {
+            // Reset seen set when structural block ends
+            if (!lastWasStructural || trimmed === "") {
+                seen.clear();
+            }
+            lastWasStructural = false;
+        }
+        result.push(line);
+    }
+    return result.join("\n");
+}
+function applyAggressiveTransformations(content, preserveHeadings) {
+    let count = 0;
+    let result = content;
+    const after1 = removeMarkdownEmphasis(result);
+    if (after1 !== result)
+        count++;
+    result = after1;
+    const after2 = removeMarkdownLinks(result);
+    if (after2 !== result)
+        count++;
+    result = after2;
+    const after3 = truncateLongLines(result);
+    if (after3 !== result)
+        count++;
+    result = after3;
+    const after4 = removeBulletMarkers(result);
+    if (after4 !== result)
+        count++;
+    result = after4;
+    const after5 = removeBlockquoteMarkers(result);
+    if (after5 !== result)
+        count++;
+    result = after5;
+    const after6 = deduplicateStructuralPatterns(result);
+    if (after6 !== result)
+        count++;
+    result = after6;
+    return { content: result, count };
+}
+function extractHeadings(content) {
+    const headings = new Map();
+    let counter = 0;
+    const text = content.replace(/^(#{1,6}\s.+)$/gm, (match) => {
+        const placeholder = `\x00HEADING_${counter++}\x00`;
+        headings.set(placeholder, match);
+        return placeholder;
+    });
+    return { text, headings };
+}
+function restoreHeadings(text, headings) {
+    let result = text;
+    for (const [placeholder, heading] of headings) {
+        result = result.replace(placeholder, heading);
+    }
+    return result;
+}
+// ─── Public API ─────────────────────────────────────────────────────────────
+/**
+ * Compress prompt content using deterministic text transformations.
+ */
+export function compressPrompt(content, options) {
+    const level = options?.level ?? "moderate";
+    const preserveHeadings = options?.preserveHeadings ?? true;
+    const preserveCodeBlocks = options?.preserveCodeBlocks ?? true;
+    if (content === "") {
+        return {
+            content: "",
+            originalChars: 0,
+            compressedChars: 0,
+            savingsPercent: 0,
+            level,
+            transformationsApplied: 0,
+        };
+    }
+    const originalChars = content.length;
+    let working = content;
+    let totalTransformations = 0;
+    // Extract code blocks if preserving
+    let codeBlocks = null;
+    if (preserveCodeBlocks) {
+        const extracted = extractCodeBlocks(working);
+        working = extracted.text;
+        codeBlocks = extracted.blocks;
+    }
+    // Extract headings if preserving
+    let headings = null;
+    if (preserveHeadings) {
+        const extracted = extractHeadings(working);
+        working = extracted.text;
+        headings = extracted.headings;
+    }
+    // Apply light transformations (always)
+    const lightResult = applyLightTransformations(working);
+    working = lightResult.content;
+    totalTransformations += lightResult.count;
+    // Check target
+    if (options?.targetChars && getRestoredLength(working, codeBlocks, headings) <= options.targetChars) {
+        return buildResult(working, originalChars, level, totalTransformations, codeBlocks, headings);
+    }
+    // Apply moderate transformations
+    if (level === "moderate" || level === "aggressive") {
+        const modResult = applyModerateTransformations(working);
+        working = modResult.content;
+        totalTransformations += modResult.count;
+        if (options?.targetChars && getRestoredLength(working, codeBlocks, headings) <= options.targetChars) {
+            return buildResult(working, originalChars, level, totalTransformations, codeBlocks, headings);
+        }
+    }
+    // Apply aggressive transformations
+    if (level === "aggressive") {
+        const aggResult = applyAggressiveTransformations(working, preserveHeadings);
+        working = aggResult.content;
+        totalTransformations += aggResult.count;
+    }
+    return buildResult(working, originalChars, level, totalTransformations, codeBlocks, headings);
+}
+/**
+ * Compress with a target size — applies progressively more aggressive
+ * compression until the target is reached or all transformations exhausted.
+ */
+export function compressToTarget(content, targetChars) {
+    if (content.length <= targetChars) {
+        return {
+            content,
+            originalChars: content.length,
+            compressedChars: content.length,
+            savingsPercent: 0,
+            level: "light",
+            transformationsApplied: 0,
+        };
+    }
+    const levels = ["light", "moderate", "aggressive"];
+    for (const level of levels) {
+        const result = compressPrompt(content, { level, targetChars });
+        if (result.compressedChars <= targetChars) {
+            return result;
+        }
+        // If aggressive and still over target, return best effort
+        if (level === "aggressive") {
+            return result;
+        }
+    }
+    // Unreachable, but satisfy TypeScript
+    return compressPrompt(content, { level: "aggressive" });
+}
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function getRestoredLength(text, codeBlocks, headings) {
+    let result = text;
+    if (headings)
+        result = restoreHeadings(result, headings);
+    if (codeBlocks)
+        result = restoreCodeBlocks(result, codeBlocks);
+    return result.length;
+}
+function buildResult(working, originalChars, level, transformationsApplied, codeBlocks, headings) {
+    let content = working;
+    if (headings)
+        content = restoreHeadings(content, headings);
+    if (codeBlocks)
+        content = restoreCodeBlocks(content, codeBlocks);
+    const compressedChars = content.length;
+    const savingsPercent = originalChars > 0
+        ? Math.round(((originalChars - compressedChars) / originalChars) * 10000) / 100
+        : 0;
+    return {
+        content,
+        originalChars,
+        compressedChars,
+        savingsPercent,
+        level,
+        transformationsApplied,
+    };
+}

package/dist/resources/extensions/gsd/prompt-loader.js

@@ -0,0 +1,119 @@
+/**
+ * GSD Prompt Loader
+ *
+ * Reads .md prompt templates from the prompts/ directory and substitutes
+ * {{variable}} placeholders with provided values.
+ *
+ * Templates live at prompts/ relative to this module's directory.
+ * They use {{variableName}} syntax for substitution.
+ *
+ * All templates are eagerly loaded into cache at module init via warmCache().
+ * This prevents a running session from being invalidated when another `gsd`
+ * launch overwrites ~/.gsd/agent/ with newer templates via initResources().
+ * Without eager caching, the in-memory extension code (which knows variable
+ * set A) can read a newer template from disk (which expects variable set B),
+ * causing a "template declares {{X}} but no value was provided" crash
+ * mid-session — especially for late-loading templates like complete-milestone
+ * that aren't read until the end of a long auto-mode run.
+ */
+import { readFileSync, readdirSync } from "node:fs";
+import { GSDError, GSD_PARSE_ERROR } from "./errors.js";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __extensionDir = dirname(fileURLToPath(import.meta.url));
+const promptsDir = join(__extensionDir, "prompts");
+const templatesDir = join(__extensionDir, "templates");
+// Cache all templates eagerly at module load — a running session uses the
+// template versions that were on disk at startup, immune to later overwrites.
+const templateCache = new Map();
+/**
+ * Eagerly read all .md files from prompts/ and templates/ into cache.
+ * Called once at module init so that every template is snapshot before
+ * a concurrent initResources() can overwrite files on disk.
+ */
+function warmCache() {
+    try {
+        for (const file of readdirSync(promptsDir)) {
+            if (!file.endsWith(".md"))
+                continue;
+            const name = file.slice(0, -3);
+            if (!templateCache.has(name)) {
+                templateCache.set(name, readFileSync(join(promptsDir, file), "utf-8"));
+            }
+        }
+    }
+    catch {
+        // prompts/ may not exist in test environments — lazy loading still works
+    }
+    try {
+        for (const file of readdirSync(templatesDir)) {
+            if (!file.endsWith(".md"))
+                continue;
+            const cacheKey = `tpl:${file.slice(0, -3)}`;
+            if (!templateCache.has(cacheKey)) {
+                templateCache.set(cacheKey, readFileSync(join(templatesDir, file), "utf-8"));
+            }
+        }
+    }
+    catch {
+        // templates/ may not exist in test environments — lazy loading still works
+    }
+}
+// Snapshot all templates at module load time
+warmCache();
+/**
+ * Load a prompt template and substitute variables.
+ *
+ * @param name - Template filename without .md extension (e.g. "execute-task")
+ * @param vars - Key-value pairs to substitute for {{key}} placeholders
+ */
+export function loadPrompt(name, vars = {}) {
+    let content = templateCache.get(name);
+    if (content === undefined) {
+        const path = join(promptsDir, `${name}.md`);
+        content = readFileSync(path, "utf-8");
+        templateCache.set(name, content);
+    }
+    // Check BEFORE substitution: find all {{varName}} placeholders the template
+    // declares and verify every one has a value in vars. Checking after substitution
+    // would also flag {{...}} patterns injected by inlined content (e.g. template
+    // files embedded in {{inlinedContext}}), producing false positives.
+    const declared = content.match(/\{\{[a-zA-Z][a-zA-Z0-9_]*\}\}/g);
+    if (declared) {
+        const missing = [...new Set(declared)]
+            .map(m => m.slice(2, -2))
+            .filter(key => !(key in vars));
+        if (missing.length > 0) {
+            throw new GSDError(GSD_PARSE_ERROR, `loadPrompt("${name}"): template declares {{${missing.join("}}, {{")}}}} but no value was provided. ` +
+                `This usually means the extension code in memory is older than the template on disk. ` +
+                `Restart pi to reload the extension.`);
+        }
+    }
+    for (const [key, value] of Object.entries(vars)) {
+        content = content.replaceAll(`{{${key}}}`, value);
+    }
+    return content.trim();
+}
+/**
+ * Load a raw template file from the templates/ directory.
+ * Cached with a `tpl:` prefix to avoid collisions with prompt cache keys.
+ */
+export function loadTemplate(name) {
+    const cacheKey = `tpl:${name}`;
+    let content = templateCache.get(cacheKey);
+    if (content === undefined) {
+        const path = join(templatesDir, `${name}.md`);
+        content = readFileSync(path, "utf-8");
+        templateCache.set(cacheKey, content);
+    }
+    return content.trim();
+}
+/**
+ * Load a template and wrap it with a labeled footer for inlining into prompts.
+ * The template body is emitted first so that any YAML frontmatter (---) remains
+ * at the first non-whitespace line of the template content.
+ */
+export function inlineTemplate(name, label) {
+    const content = loadTemplate(name);
+    return `${content}\n\n### Output Template: ${label}\nSource: \`templates/${name}.md\``;
+}

package/dist/resources/extensions/gsd/prompt-ordering.js

@@ -0,0 +1,170 @@
+/**
+ * Prompt Ordering Optimizer — reorders assembled prompt sections
+ * to maximize cache prefix stability.
+ *
+ * Identifies sections by markdown heading patterns and rearranges
+ * them so stable content appears first. Anthropic caches the last
+ * user message by prefix match, so placing static/semi-static
+ * content before dynamic content improves cache hit rates.
+ */
+/**
+ * Known heading to role mappings for GSD prompts.
+ * Static: templates, executor constraints, system instructions
+ * Semi-static: slice plan, decisions, requirements, prior summaries, overrides
+ * Dynamic: task plan, resume state, carry-forward, verification
+ */
+const HEADING_ROLES = {
+    // Static — never changes per task
+    "Output Template": "static",
+    "Executor Context Constraints": "static",
+    "Working Directory": "static",
+    "Backing Source Artifacts": "static",
+    // Semi-static — changes per slice but not per task
+    "Slice Plan Excerpt": "semi-static",
+    "Decisions": "semi-static",
+    "Requirements": "semi-static",
+    "Prior Task Summaries": "semi-static",
+    "Overrides": "semi-static",
+    "Project Knowledge": "semi-static",
+    "Dependency Summaries": "semi-static",
+    // Dynamic — changes per task
+    "Inlined Task Plan": "dynamic",
+    "Resume State": "dynamic",
+    "Carry-Forward Context": "dynamic",
+    "Verification": "dynamic",
+    "Verification Evidence": "dynamic",
+};
+/**
+ * Extract the heading text from a line like "## Some Heading" or "## UNIT: Execute Task ...".
+ * Returns the full text after "## " for role lookup.
+ */
+function extractHeadingText(line) {
+    return line.replace(/^##\s+/, "").trim();
+}
+/**
+ * Classify a heading by matching against known roles.
+ * Uses substring matching so headings like "## UNIT: Execute Task T1.1" don't match
+ * but "## Inlined Task Plan" does. Unknown headings default to "dynamic".
+ */
+function classifyHeading(heading) {
+    for (const [key, role] of Object.entries(HEADING_ROLES)) {
+        if (heading === key || heading.startsWith(key)) {
+            return role;
+        }
+    }
+    return "dynamic";
+}
+/**
+ * Split a prompt into sections at ## heading boundaries.
+ * Sub-headings (### and deeper) stay with their parent ## section.
+ * Returns a preamble (content before first ##) and an array of sections.
+ */
+function splitSections(prompt) {
+    const lines = prompt.split("\n");
+    let preamble = "";
+    const sections = [];
+    let currentHeading = "";
+    let currentContent = [];
+    for (const line of lines) {
+        // Match ## headings but NOT ### or deeper
+        if (/^## (?!#)/.test(line)) {
+            // Flush previous section
+            if (currentHeading) {
+                sections.push({
+                    heading: currentHeading,
+                    content: currentContent.join("\n"),
+                    role: classifyHeading(currentHeading),
+                });
+            }
+            else if (currentContent.length > 0) {
+                preamble = currentContent.join("\n");
+            }
+            currentHeading = extractHeadingText(line);
+            currentContent = [line];
+        }
+        else {
+            currentContent.push(line);
+        }
+    }
+    // Flush last section
+    if (currentHeading) {
+        sections.push({
+            heading: currentHeading,
+            content: currentContent.join("\n"),
+            role: classifyHeading(currentHeading),
+        });
+    }
+    else if (currentContent.length > 0) {
+        preamble = currentContent.join("\n");
+    }
+    return { preamble, sections };
+}
+const ROLE_ORDER = {
+    "static": 0,
+    "semi-static": 1,
+    "dynamic": 2,
+};
+/**
+ * Reorder a prompt's sections for cache efficiency.
+ * Extracts sections by ## heading markers, classifies them,
+ * and reorders: static -> semi-static -> dynamic.
+ *
+ * Content before the first ## heading is treated as a preamble
+ * and always placed first (it's usually static instructions).
+ *
+ * @param prompt The assembled prompt string
+ * @returns Reordered prompt string
+ */
+export function reorderForCaching(prompt) {
+    const { preamble, sections } = splitSections(prompt);
+    // Nothing to reorder
+    if (sections.length <= 1) {
+        return prompt;
+    }
+    // Stable sort: sections with the same role keep their original relative order
+    const sorted = [...sections].sort((a, b) => {
+        return ROLE_ORDER[a.role] - ROLE_ORDER[b.role];
+    });
+    const parts = [];
+    if (preamble) {
+        parts.push(preamble);
+    }
+    for (const section of sorted) {
+        parts.push(section.content);
+    }
+    return parts.join("\n");
+}
+/**
+ * Analyze a prompt's cache efficiency without reordering.
+ * Returns stats about how much of the prompt is cacheable.
+ */
+export function analyzeCacheEfficiency(prompt) {
+    const { preamble, sections } = splitSections(prompt);
+    let staticChars = preamble.length;
+    let semiStaticChars = 0;
+    let dynamicChars = 0;
+    for (const section of sections) {
+        switch (section.role) {
+            case "static":
+                staticChars += section.content.length;
+                break;
+            case "semi-static":
+                semiStaticChars += section.content.length;
+                break;
+            case "dynamic":
+                dynamicChars += section.content.length;
+                break;
+        }
+    }
+    const totalChars = staticChars + semiStaticChars + dynamicChars;
+    const cacheEfficiency = totalChars > 0
+        ? (staticChars + semiStaticChars) / totalChars
+        : 0;
+    return {
+        totalChars,
+        staticChars,
+        semiStaticChars,
+        dynamicChars,
+        cacheEfficiency,
+    };
+}