gsd-pi 2.28.0 → 2.29.0-dev.2ccf3fb

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

@@ -0,0 +1,144 @@
+/**
+ * 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
+ */
+
+// ---------------------------------------------------------------------------
+// Types (inline — no imports from other GSD modules)
+// ---------------------------------------------------------------------------
+
+interface DecisionInput {
+  id: string;
+  when_context: string;
+  scope: string;
+  decision: string;
+  choice: string;
+  rationale: string;
+  revisable: string;
+}
+
+interface RequirementInput {
+  id: string;
+  class: string;
+  status: string;
+  description: string;
+  why: string;
+  primary_owner: string;
+  validation: string;
+}
+
+interface TaskPlanInput {
+  id: string;
+  title: string;
+  description: string;
+  done: boolean;
+  estimate: string;
+  files?: string[];
+  verify?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Decisions
+// ---------------------------------------------------------------------------
+
+/** Compact format for a single decision record (pipe-separated, no padding). */
+export function formatDecisionCompact(decision: DecisionInput): string {
+  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: DecisionInput[]): string {
+  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: RequirementInput): string {
+  const lines: string[] = [];
+  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: RequirementInput[]): string {
+  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: TaskPlanInput[]): string {
+  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: string[] = [];
+    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: string, markdownContent: string): number {
+  if (markdownContent.length === 0) return 0;
+  const saved = markdownContent.length - compactContent.length;
+  return (saved / markdownContent.length) * 100;
+}

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

@@ -0,0 +1,258 @@
+/**
+ * Summary distiller — extracts essential structured data from SUMMARY.md files,
+ * dropping verbose prose to save context budget.
+ */
+
+export interface DistillationResult {
+  content: string;
+  summaryCount: number;
+  savingsPercent: number;
+  originalChars: number;
+  distilledChars: number;
+}
+
+interface ParsedFrontmatter {
+  id: string;
+  provides: string[];
+  requires: string[];
+  key_files: string[];
+  key_decisions: string[];
+  patterns_established: string[];
+}
+
+interface DistilledEntry {
+  id: string;
+  oneLiner: string;
+  provides: string[];
+  requires: string[];
+  key_files: string[];
+  key_decisions: string[];
+  patterns: string[];
+}
+
+// ─── Frontmatter parsing ─────────────────────────────────────────────────────
+
+function parseFrontmatter(raw: string): ParsedFrontmatter {
+  const result: ParsedFrontmatter = {
+    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: string | null = 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: ParsedFrontmatter, key: string, value: string): void {
+  if (key === "id") fm.id = value;
+}
+
+function pushItem(fm: ParsedFrontmatter, key: string, value: string): void {
+  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: string): { id: string; oneLiner: string } {
+  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: string): string {
+  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: string): string {
+  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: DistilledEntry): string {
+  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: DistilledEntry, dropLevel: number): string {
+  const lines: string[] = [];
+  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: string[], budgetChars: number): DistillationResult {
+  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: DistilledEntry[] = 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/tests/activity-log.test.ts

@@ -0,0 +1,213 @@
+/**
+ * Activity log tests — consolidated from:
+ *   - activity-log-prune.test.ts (age-based pruning with highest-seq preservation)
+ *   - activity-log-save.test.ts (caching, dedup, collision recovery)
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, mkdirSync, readdirSync, rmSync, utimesSync, writeFileSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+import { pruneActivityLogs, saveActivityLog } from "../activity-log.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function createTmpDir(): string {
+  return mkdtempSync(join(tmpdir(), "gsd-activity-test-"));
+}
+
+function writeActivityFile(dir: string, seq: string, name: string): string {
+  mkdirSync(dir, { recursive: true });
+  const filePath = join(dir, `${seq}-${name}.jsonl`);
+  writeFileSync(filePath, `{"seq":${parseInt(seq, 10)},"name":"${name}"}\n`, "utf-8");
+  return filePath;
+}
+
+function backdateFile(filePath: string, daysAgo: number): void {
+  const pastMs = Date.now() - daysAgo * 24 * 60 * 60 * 1000;
+  const pastDate = new Date(pastMs);
+  utimesSync(filePath, pastDate, pastDate);
+}
+
+function listFiles(dir: string): string[] {
+  return existsSync(dir) ? readdirSync(dir).sort() : [];
+}
+
+function activityDir(baseDir: string): string {
+  return join(baseDir, ".gsd", "activity");
+}
+
+function createCtx(entries: unknown[]) {
+  return { sessionManager: { getEntries: () => entries } };
+}
+
+// ── Pruning ──────────────────────────────────────────────────────────────────
+
+test("pruneActivityLogs deletes old files, keeps recent and highest-seq", () => {
+  const dir = createTmpDir();
+  try {
+    const f001 = writeActivityFile(dir, "001", "execute-task-M001-S01-T01");
+    writeActivityFile(dir, "002", "execute-task-M001-S01-T02");
+    writeActivityFile(dir, "003", "execute-task-M001-S01-T03");
+    backdateFile(f001, 40);
+
+    pruneActivityLogs(dir, 30);
+    const remaining = listFiles(dir);
+    assert.ok(!remaining.includes("001-execute-task-M001-S01-T01.jsonl"));
+    assert.ok(remaining.includes("002-execute-task-M001-S01-T02.jsonl"));
+    assert.ok(remaining.includes("003-execute-task-M001-S01-T03.jsonl"));
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("pruneActivityLogs preserves highest-seq even when all files are old", () => {
+  const dir = createTmpDir();
+  try {
+    const f001 = writeActivityFile(dir, "001", "t1");
+    const f002 = writeActivityFile(dir, "002", "t2");
+    const f003 = writeActivityFile(dir, "003", "t3");
+    backdateFile(f001, 40); backdateFile(f002, 40); backdateFile(f003, 40);
+
+    pruneActivityLogs(dir, 30);
+    const remaining = listFiles(dir);
+    assert.equal(remaining.length, 1);
+    assert.ok(remaining[0].startsWith("003-"));
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("pruneActivityLogs with retentionDays=0 keeps only highest-seq", () => {
+  const dir = createTmpDir();
+  try {
+    writeActivityFile(dir, "001", "t1");
+    writeActivityFile(dir, "002", "t2");
+    writeActivityFile(dir, "003", "t3");
+
+    pruneActivityLogs(dir, 0);
+    const remaining = listFiles(dir);
+    assert.equal(remaining.length, 1);
+    assert.ok(remaining[0].startsWith("003-"));
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("pruneActivityLogs no-op when all files are recent", () => {
+  const dir = createTmpDir();
+  try {
+    writeActivityFile(dir, "001", "t1");
+    writeActivityFile(dir, "002", "t2");
+    writeActivityFile(dir, "003", "t3");
+
+    pruneActivityLogs(dir, 30);
+    assert.equal(listFiles(dir).length, 3);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("pruneActivityLogs handles empty directory", () => {
+  const dir = createTmpDir();
+  try {
+    assert.doesNotThrow(() => pruneActivityLogs(dir, 30));
+    assert.equal(readdirSync(dir).length, 0);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("pruneActivityLogs preserves single old file (it is highest-seq)", () => {
+  const dir = createTmpDir();
+  try {
+    const f = writeActivityFile(dir, "001", "t1");
+    backdateFile(f, 100);
+
+    pruneActivityLogs(dir, 30);
+    assert.equal(listFiles(dir).length, 1);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("pruneActivityLogs ignores non-matching filenames", () => {
+  const dir = createTmpDir();
+  try {
+    const f001 = writeActivityFile(dir, "001", "t1");
+    writeFileSync(join(dir, "notes.txt"), "some notes\n", "utf-8");
+    backdateFile(f001, 40);
+
+    assert.doesNotThrow(() => pruneActivityLogs(dir, 30));
+    const remaining = listFiles(dir);
+    assert.ok(remaining.includes("notes.txt"));
+    // 001 is the only seq file, so it's highest-seq and survives
+    assert.ok(remaining.includes("001-t1.jsonl"));
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// ── Save: caching, dedup, collision recovery ─────────────────────────────────
+
+test("saveActivityLog caches sequence instead of rescanning", () => {
+  const baseDir = createTmpDir();
+  try {
+    saveActivityLog(createCtx([{ kind: "first", n: 1 }]) as any, baseDir, "execute-task", "M001/S01/T01");
+    writeFileSync(join(activityDir(baseDir), "999-external.jsonl"), '{"x":1}\n', "utf-8");
+    saveActivityLog(createCtx([{ kind: "second", n: 2 }]) as any, baseDir, "execute-task", "M001/S01/T02");
+
+    const files = listFiles(activityDir(baseDir));
+    assert.ok(files.includes("001-execute-task-M001-S01-T01.jsonl"));
+    assert.ok(files.includes("002-execute-task-M001-S01-T02.jsonl"));
+    assert.ok(!files.some(f => f.startsWith("1000-")));
+  } finally {
+    rmSync(baseDir, { recursive: true, force: true });
+  }
+});
+
+test("saveActivityLog deduplicates identical snapshots for same unit", () => {
+  const baseDir = createTmpDir();
+  try {
+    const ctx = createCtx([{ role: "assistant", content: "same" }]);
+    saveActivityLog(ctx as any, baseDir, "plan-slice", "M002/S01");
+    saveActivityLog(ctx as any, baseDir, "plan-slice", "M002/S01");
+
+    let files = listFiles(activityDir(baseDir));
+    assert.equal(files.length, 1);
+
+    saveActivityLog(createCtx([{ role: "assistant", content: "changed" }]) as any, baseDir, "plan-slice", "M002/S01");
+    files = listFiles(activityDir(baseDir));
+    assert.equal(files.length, 2);
+  } finally {
+    rmSync(baseDir, { recursive: true, force: true });
+  }
+});
+
+test("saveActivityLog recovers on sequence collision", () => {
+  const baseDir = createTmpDir();
+  try {
+    saveActivityLog(createCtx([{ turn: 1 }]) as any, baseDir, "execute-task", "M003/S02/T01");
+    writeFileSync(join(activityDir(baseDir), "002-execute-task-M003-S02-T02.jsonl"), '{"collision":true}\n', "utf-8");
+    saveActivityLog(createCtx([{ turn: 2 }]) as any, baseDir, "execute-task", "M003/S02/T02");
+
+    const files = listFiles(activityDir(baseDir));
+    assert.ok(files.includes("002-execute-task-M003-S02-T02.jsonl"));
+    assert.ok(files.includes("003-execute-task-M003-S02-T02.jsonl"));
+  } finally {
+    rmSync(baseDir, { recursive: true, force: true });
+  }
+});
+
+// ── Prompt text assertion ────────────────────────────────────────────────────
+
+test("complete-slice.md contains refresh state instruction", () => {
+  const promptPath = join(__dirname, "..", "prompts", "complete-slice.md");
+  const content = readFileSync(promptPath, "utf-8");
+  assert.ok(content.includes("refresh current state if needed"));
+});