gsd-pi 2.38.0-dev.add4f78 → 2.38.0-dev.d533afb

package/src/resources/extensions/gsd/tests/repo-identity-worktree.test.ts

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { externalGsdRoot, ensureGsdSymlink } from "../repo-identity.ts";
+import { repoIdentity, externalGsdRoot, ensureGsdSymlink, validateProjectId } from "../repo-identity.ts";
 import { createTestContext } from "./test-helpers.ts";
 
 const { assertEq, assertTrue, report } = createTestContext();
@@ -57,6 +57,26 @@ async function main(): Promise<void> {
     assertEq(preservedDirState, join(worktreePath, ".gsd"), "worktree .gsd directory is left in place for sync-based refresh");
     assertTrue(lstatSync(join(worktreePath, ".gsd")).isDirectory(), "worktree .gsd directory remains a directory");
     assertTrue(existsSync(join(worktreePath, ".gsd", "milestones", "stale.txt")), "existing worktree .gsd directory contents remain available for sync logic");
+
+    console.log("\n=== GSD_PROJECT_ID overrides computed repo hash ===");
+    process.env.GSD_PROJECT_ID = "my-project";
+    assertEq(repoIdentity(base), "my-project", "repoIdentity returns GSD_PROJECT_ID when set");
+    assertEq(externalGsdRoot(base), join(stateDir, "projects", "my-project"), "externalGsdRoot uses GSD_PROJECT_ID");
+    delete process.env.GSD_PROJECT_ID;
+
+    console.log("\n=== GSD_PROJECT_ID falls back to hash when unset ===");
+    const hashIdentity = repoIdentity(base);
+    assertTrue(/^[0-9a-f]{12}$/.test(hashIdentity), "repoIdentity returns 12-char hex hash when GSD_PROJECT_ID is unset");
+
+    console.log("\n=== validateProjectId rejects invalid values ===");
+    for (const invalid of ["has spaces", "path/traversal", "dot..dot", "back\\slash"]) {
+      assertTrue(!validateProjectId(invalid), `validateProjectId rejects invalid value: "${invalid}"`);
+    }
+
+    console.log("\n=== validateProjectId accepts valid values ===");
+    for (const valid of ["my-project", "foo_bar", "abc123", "A-Z_0-9"]) {
+      assertTrue(validateProjectId(valid), `validateProjectId accepts valid value: "${valid}"`);
+    }
   } finally {
     delete process.env.GSD_STATE_DIR;
     rmSync(base, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/run-uat.test.ts

@@ -210,7 +210,7 @@ async function main(): Promise<void> {
   const sliceId = 'S01';
   const uatPath = '.gsd/milestones/M001/slices/S01/S01-UAT.md';
   const uatResultPath = '.gsd/milestones/M001/slices/S01/S01-UAT-RESULT.md';
-  const uatType = 'artifact-driven';
+  const uatType = 'live-runtime';
   const inlinedContext = '<!-- no context -->';
 
   let promptResult: string | undefined;
@@ -246,13 +246,21 @@ async function main(): Promise<void> {
     promptResult?.includes(uatResultPath) ?? false,
     `prompt contains uatResultPath value after substitution`,
   );
+  assertTrue(
+    promptResult?.includes(`Detected UAT mode:** \`${uatType}\``) ?? false,
+    `prompt contains detected dynamic uatType value "${uatType}" after substitution`,
+  );
+  assertTrue(
+    promptResult?.includes(`uatType: ${uatType}`) ?? false,
+    `prompt contains dynamic uatType frontmatter value "${uatType}" after substitution`,
+  );
   assertTrue(
     !/\{\{[^}]+\}\}/.test(promptResult ?? ''),
     'no unreplaced {{...}} tokens remain after variable substitution',
   );
   assertTrue(
-    /artifact|execute|run/i.test(promptResult ?? ''),
-    'prompt contains artifact-driven execution language (artifact/execute/run)',
+    /browser|runtime|execute|run/i.test(promptResult ?? ''),
+    'prompt contains runtime execution language (browser/runtime/execute/run)',
   );
   assertTrue(
     !/surfaced for human review/i.test(promptResult ?? ''),

package/src/resources/extensions/gsd/types.ts

@@ -423,7 +423,6 @@ export interface Requirement {
 
 // ─── Parallel Orchestration Types ────────────────────────────────────────
 
-export type CompressionStrategy = "truncate" | "compress";
 export type ContextSelectionMode = "full" | "smart";
 
 export type MergeStrategy = "per-slice" | "per-milestone";

package/src/resources/extensions/mcp-client/index.ts

@@ -114,6 +114,22 @@ function getServerConfig(name: string): McpServerConfig | undefined {
 	return readConfigs().find((s) => s.name === name);
 }
 
+/** Resolve ${VAR} references in env values against process.env. */
+function resolveEnv(env: Record<string, string>): Record<string, string> {
+	const resolved: Record<string, string> = {};
+	for (const [key, value] of Object.entries(env)) {
+		if (typeof value === "string") {
+			resolved[key] = value.replace(
+				/\$\{([^}]+)\}/g,
+				(_match, varName) => process.env[varName] ?? "",
+			);
+		} else {
+			resolved[key] = value;
+		}
+	}
+	return resolved;
+}
+
 async function getOrConnect(name: string, signal?: AbortSignal): Promise<Client> {
 	const existing = connections.get(name);
 	if (existing) return existing.client;
@@ -128,7 +144,7 @@ async function getOrConnect(name: string, signal?: AbortSignal): Promise<Client>
 		transport = new StdioClientTransport({
 			command: config.command,
 			args: config.args,
-			env: config.env ? { ...process.env, ...config.env } as Record<string, string> : undefined,
+			env: config.env ? { ...process.env, ...resolveEnv(config.env) } as Record<string, string> : undefined,
 			cwd: config.cwd,
 			stderr: "pipe",
 		});

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

@@ -1,393 +0,0 @@
-/**
- * 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,
-    };
-}