lsd-pi 1.0.0 → 1.1.0

package/src/resources/extensions/gsd/tests/forensics-error-filter.test.ts

@@ -1,121 +0,0 @@
-/**
- * Regression test for #2539: extractTrace should not count benign bash
- * exit-code-1 (grep no-match) or user skips as errors.
- */
-import { describe, test } from "node:test";
-import assert from "node:assert/strict";
-
-import { extractTrace } from "../session-forensics.ts";
-
-/**
- * Build a minimal JSONL entry pair: assistant tool_use → toolResult.
- * This is the shape extractTrace() expects from session activity files.
- */
-function makeToolPair(
-  toolName: string,
-  input: Record<string, unknown>,
-  resultText: string,
-  isError: boolean,
-): unknown[] {
-  const toolCallId = `toolu_${Math.random().toString(36).slice(2, 10)}`;
-  return [
-    {
-      type: "message",
-      message: {
-        role: "assistant",
-        content: [
-          {
-            type: "toolCall",
-            id: toolCallId,
-            name: toolName,
-            arguments: input,
-          },
-        ],
-      },
-    },
-    {
-      type: "message",
-      message: {
-        role: "toolResult",
-        toolCallId,
-        toolName,
-        isError,
-        content: [{ type: "text", text: resultText }],
-      },
-    },
-  ];
-}
-
-describe("extractTrace error filtering (#2539)", () => {
-  test("grep exit-code-1 (no matches) is not counted as an error", () => {
-    const entries = makeToolPair(
-      "bash",
-      { command: "grep -rn 'nonexistent' src/" },
-      "(no output)\nCommand exited with code 1",
-      true,
-    );
-    const trace = extractTrace(entries);
-    assert.equal(trace.errors.length, 0, "grep no-match should not be an error");
-  });
-
-  test("user skip is not counted as an error", () => {
-    const entries = makeToolPair(
-      "bash",
-      { command: "npm run test" },
-      "Skipped due to queued user message",
-      true,
-    );
-    const trace = extractTrace(entries);
-    assert.equal(trace.errors.length, 0, "user skip should not be an error");
-  });
-
-  test("real bash error is still counted", () => {
-    const entries = makeToolPair(
-      "bash",
-      { command: "cat /nonexistent" },
-      "cat: /nonexistent: No such file or directory\nCommand exited with code 1",
-      true,
-    );
-    const trace = extractTrace(entries);
-    assert.equal(trace.errors.length, 1, "real error should still be counted");
-    assert.match(trace.errors[0], /No such file or directory/);
-  });
-
-  test("non-bash tool error is still counted", () => {
-    const entries = makeToolPair(
-      "edit",
-      { path: "foo.ts", oldText: "x", newText: "y" },
-      "oldText not found in file",
-      true,
-    );
-    const trace = extractTrace(entries);
-    assert.equal(trace.errors.length, 1, "non-bash tool errors should still be counted");
-  });
-
-  test("mixed entries: only real errors are counted", () => {
-    const entries = [
-      // benign grep no-match
-      ...makeToolPair("bash", { command: "grep -rn 'pattern' src/" }, "(no output)\nCommand exited with code 1", true),
-      // user skip
-      ...makeToolPair("bash", { command: "npm test" }, "Skipped due to queued user message", true),
-      // real error
-      ...makeToolPair("bash", { command: "node broken.js" }, "SyntaxError: Unexpected token\nCommand exited with code 1", true),
-      // successful command (not an error)
-      ...makeToolPair("bash", { command: "echo hello" }, "hello", false),
-    ];
-    const trace = extractTrace(entries);
-    assert.equal(trace.errors.length, 1, "only the real error should be counted");
-    assert.match(trace.errors[0], /SyntaxError/);
-  });
-
-  test("exit code 1 with actual output is still an error", () => {
-    const entries = makeToolPair(
-      "bash",
-      { command: "npm run lint" },
-      "src/foo.ts:10:5 - error TS2304: Cannot find name 'x'\nCommand exited with code 1",
-      true,
-    );
-    const trace = extractTrace(entries);
-    assert.equal(trace.errors.length, 1, "lint error with output should be counted");
-  });
-});

package/src/resources/extensions/gsd/tests/forensics-issue-routing.test.ts

@@ -1,43 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-const promptsDir = join(process.cwd(), "src/resources/extensions/gsd/prompts");
-
-function readPrompt(name: string): string {
-  return readFileSync(join(promptsDir, `${name}.md`), "utf-8");
-}
-
-test("forensics prompt explicitly forbids github_issues tool for issue creation", () => {
-  const prompt = readPrompt("forensics");
-
-  // Must contain an explicit prohibition against using the github_issues tool
-  assert.match(
-    prompt,
-    /Do NOT use the `?github_issues`? tool/i,
-    "Prompt must explicitly prohibit the github_issues tool",
-  );
-});
-
-test("forensics prompt requires gh CLI with --repo gsd-build/gsd-2 for issue creation", () => {
-  const prompt = readPrompt("forensics");
-
-  // Must contain the exact gh CLI command with the correct repo flag
-  assert.match(
-    prompt,
-    /gh issue create --repo gsd-build\/gsd-2/,
-    "Prompt must specify gh issue create --repo gsd-build/gsd-2",
-  );
-});
-
-test("forensics prompt routes issue creation through bash tool, not github_issues", () => {
-  const prompt = readPrompt("forensics");
-
-  // The constraint about using bash tool must be present
-  assert.match(
-    prompt,
-    /`?bash`? tool/i,
-    "Prompt must instruct use of the bash tool for issue creation",
-  );
-});

package/src/resources/extensions/gsd/tests/forensics-journal.test.ts

@@ -1,162 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const gsdDir = join(__dirname, "..");
-
-describe("forensics journal & activity log awareness", () => {
-  const forensicsSrc = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
-  const promptSrc = readFileSync(join(gsdDir, "prompts", "forensics.md"), "utf-8");
-
-  it("scanJournalForForensics reads journal files directly (no full queryJournal load)", () => {
-    // Must NOT use queryJournal which loads ALL entries into memory
-    assert.ok(
-      !forensicsSrc.includes('queryJournal('),
-      "forensics.ts must NOT call queryJournal() which loads all entries at once",
-    );
-    // Must have its own journal scanning with file-level limits
-    assert.ok(
-      forensicsSrc.includes("scanJournalForForensics"),
-      "forensics.ts must have scanJournalForForensics function",
-    );
-  });
-
-  it("journal scanning limits files parsed to avoid memory bloat", () => {
-    assert.ok(
-      forensicsSrc.includes("MAX_JOURNAL_RECENT_FILES"),
-      "must have MAX_JOURNAL_RECENT_FILES constant to limit parsed files",
-    );
-    assert.ok(
-      forensicsSrc.includes("MAX_JOURNAL_RECENT_EVENTS"),
-      "must have MAX_JOURNAL_RECENT_EVENTS constant to limit events extracted",
-    );
-  });
-
-  it("older journal files are line-counted without full JSON parse", () => {
-    assert.ok(
-      forensicsSrc.includes("olderEntryCount") || forensicsSrc.includes("olderFiles"),
-      "must handle older files separately from recent files",
-    );
-  });
-
-  it("ForensicReport includes journalSummary field", () => {
-    assert.ok(
-      forensicsSrc.includes("journalSummary"),
-      "ForensicReport must include journalSummary field",
-    );
-  });
-
-  it("ForensicReport includes activityLogMeta field", () => {
-    assert.ok(
-      forensicsSrc.includes("activityLogMeta"),
-      "ForensicReport must include activityLogMeta field",
-    );
-  });
-
-  it("buildForensicReport calls scanJournalForForensics", () => {
-    assert.ok(
-      forensicsSrc.includes("scanJournalForForensics"),
-      "buildForensicReport must call scanJournalForForensics",
-    );
-  });
-
-  it("buildForensicReport calls gatherActivityLogMeta", () => {
-    assert.ok(
-      forensicsSrc.includes("gatherActivityLogMeta"),
-      "buildForensicReport must call gatherActivityLogMeta",
-    );
-  });
-
-  it("forensics detects journal-based anomalies", () => {
-    assert.ok(
-      forensicsSrc.includes("detectJournalAnomalies"),
-      "forensics.ts must have detectJournalAnomalies function",
-    );
-    // Check for specific journal anomaly types
-    assert.ok(forensicsSrc.includes('"journal-stuck"'), "must detect journal-stuck anomalies");
-    assert.ok(forensicsSrc.includes('"journal-guard-block"'), "must detect journal-guard-block anomalies");
-    assert.ok(forensicsSrc.includes('"journal-rapid-iterations"'), "must detect journal-rapid-iterations anomalies");
-    assert.ok(forensicsSrc.includes('"journal-worktree-failure"'), "must detect journal-worktree-failure anomalies");
-  });
-
-  it("formatReportForPrompt includes journal summary section", () => {
-    assert.ok(
-      forensicsSrc.includes("Journal Summary"),
-      "prompt formatter must include a Journal Summary section",
-    );
-  });
-
-  it("formatReportForPrompt includes activity log overview section", () => {
-    assert.ok(
-      forensicsSrc.includes("Activity Log Overview"),
-      "prompt formatter must include an Activity Log Overview section",
-    );
-  });
-
-  it("activity log scanning uses tail-read with byte cap (not full file load)", () => {
-    // scanActivityLogs uses nativeParseJsonlTail + MAX_JSONL_BYTES for efficient reading
-    assert.ok(
-      forensicsSrc.includes("nativeParseJsonlTail"),
-      "activity log scanning must use nativeParseJsonlTail for tail-reading",
-    );
-    assert.ok(
-      forensicsSrc.includes("MAX_JSONL_BYTES"),
-      "activity log scanning must respect MAX_JSONL_BYTES cap",
-    );
-    // Only reads last 5 files
-    assert.ok(
-      forensicsSrc.includes("slice(-5)"),
-      "activity log scanning must limit to last 5 files",
-    );
-  });
-
-  it("activity log entries are distilled through extractTrace, not sent raw", () => {
-    assert.ok(
-      forensicsSrc.includes("extractTrace("),
-      "activity log entries must be distilled through extractTrace before reporting",
-    );
-  });
-
-  it("prompt output is hard-capped at 30KB", () => {
-    assert.ok(
-      forensicsSrc.includes("MAX_BYTES") && forensicsSrc.includes("30 * 1024"),
-      "formatReportForPrompt must have a 30KB hard cap",
-    );
-    assert.ok(
-      forensicsSrc.includes("truncated at 30KB"),
-      "prompt must show truncation message when capped",
-    );
-  });
-
-  it("forensics prompt documents journal format", () => {
-    assert.ok(
-      promptSrc.includes("### Journal Format"),
-      "forensics.md must document the journal format",
-    );
-    assert.ok(
-      promptSrc.includes("flowId"),
-      "forensics.md must reference flowId concept",
-    );
-    assert.ok(
-      promptSrc.includes("causedBy"),
-      "forensics.md must reference causedBy for causal chains",
-    );
-  });
-
-  it("forensics prompt includes journal directory in runtime path reference", () => {
-    assert.ok(
-      promptSrc.includes("journal/"),
-      "forensics.md runtime path reference must include journal/",
-    );
-  });
-
-  it("investigation protocol references journal data", () => {
-    assert.ok(
-      promptSrc.includes("journal timeline") || promptSrc.includes("journal events"),
-      "investigation protocol must reference journal data for tracing",
-    );
-  });
-});

package/src/resources/extensions/gsd/tests/freeform-decisions.test.ts

@@ -1,232 +0,0 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import * as fs from 'node:fs';
-import {
-  openDatabase,
-  closeDatabase,
-} from '../gsd-db.ts';
-import {
-  parseDecisionsTable,
-} from '../md-importer.ts';
-import {
-  saveDecisionToDb,
-} from '../db-writer.ts';
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Helpers
-// ═══════════════════════════════════════════════════════════════════════════
-
-function makeTmpDir(): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-freeform-'));
-  fs.mkdirSync(path.join(dir, '.gsd'), { recursive: true });
-  return dir;
-}
-
-function cleanupDir(dir: string): void {
-  try {
-    fs.rmSync(dir, { recursive: true, force: true });
-  } catch { /* swallow */ }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Bug reproduction: freeform DECISIONS.md content destroyed (#2301)
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe('freeform-decisions', () => {
-  test('parseDecisionsTable silently drops freeform content', () => {
-    const freeform = `# Project Decisions
-
-  ## Architecture
-  We decided to use a microservices architecture because monoliths don't scale.
-
-  ## Database
-  PostgreSQL was chosen for its reliability and JSONB support.
-
-  ## Deployment
-  - Kubernetes for orchestration
-  - Helm charts for packaging
-  `;
-
-    const parsed = parseDecisionsTable(freeform);
-    assert.deepStrictEqual(parsed.length, 0, 'freeform content yields zero parsed decisions (expected — it is not a table)');
-  });
-
-  test('saveDecisionToDb destroys freeform DECISIONS.md content', async () => {
-    const tmpDir = makeTmpDir();
-    const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
-    const mdPath = path.join(tmpDir, '.gsd', 'DECISIONS.md');
-    openDatabase(dbPath);
-
-    const freeformContent = `# Project Decisions
-
-  ## Architecture
-  We decided to use a microservices architecture because monoliths don't scale.
-
-  ## Database
-  PostgreSQL was chosen for its reliability and JSONB support.
-
-  ## Deployment
-  - Kubernetes for orchestration
-  - Helm charts for packaging
-  `;
-
-    // Pre-populate DECISIONS.md with freeform content
-    fs.writeFileSync(mdPath, freeformContent, 'utf-8');
-
-    try {
-      // Save a new decision — this should NOT destroy the freeform content
-      const result = await saveDecisionToDb({
-        scope: 'testing',
-        decision: 'Use Jest for unit tests',
-        choice: 'Jest',
-        rationale: 'Well-known, good DX',
-        when_context: 'M001',
-      }, tmpDir);
-
-      assert.deepStrictEqual(result.id, 'D001', 'decision ID assigned correctly');
-
-      // Read back the file
-      const afterContent = fs.readFileSync(mdPath, 'utf-8');
-
-      // The freeform content MUST still be present
-      assert.ok(
-        afterContent.includes('microservices architecture'),
-        'freeform architecture section preserved after saveDecisionToDb',
-      );
-      assert.ok(
-        afterContent.includes('PostgreSQL was chosen'),
-        'freeform database section preserved after saveDecisionToDb',
-      );
-      assert.ok(
-        afterContent.includes('Kubernetes for orchestration'),
-        'freeform deployment section preserved after saveDecisionToDb',
-      );
-
-      // The new decision MUST also be present
-      assert.ok(
-        afterContent.includes('D001'),
-        'new decision D001 present in file',
-      );
-      assert.ok(
-        afterContent.includes('Use Jest for unit tests'),
-        'new decision text present in file',
-      );
-
-      // Save a second decision — freeform content must still survive
-      const result2 = await saveDecisionToDb({
-        scope: 'ci',
-        decision: 'Use GitHub Actions for CI',
-        choice: 'GitHub Actions',
-        rationale: 'Native integration',
-        when_context: 'M001',
-      }, tmpDir);
-
-      assert.deepStrictEqual(result2.id, 'D002', 'second decision ID assigned correctly');
-
-      const afterContent2 = fs.readFileSync(mdPath, 'utf-8');
-
-      assert.ok(
-        afterContent2.includes('microservices architecture'),
-        'freeform content still preserved after second save',
-      );
-      assert.ok(
-        afterContent2.includes('D001'),
-        'first decision still present after second save',
-      );
-      assert.ok(
-        afterContent2.includes('D002'),
-        'second decision present after second save',
-      );
-      assert.ok(
-        afterContent2.includes('Use GitHub Actions for CI'),
-        'second decision text present in file',
-      );
-    } finally {
-      closeDatabase();
-      cleanupDir(tmpDir);
-    }
-  });
-
-  test('saveDecisionToDb with table-format DECISIONS.md still regenerates normally', async () => {
-    const tmpDir = makeTmpDir();
-    const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
-    const mdPath = path.join(tmpDir, '.gsd', 'DECISIONS.md');
-    openDatabase(dbPath);
-
-    // Pre-populate with canonical table format
-    const tableContent = `# Decisions Register
-
-  <!-- Append-only. Never edit or remove existing rows.
-       To reverse a decision, add a new row that supersedes it.
-       Read this file at the start of any planning or research phase. -->
-
-  | # | When | Scope | Decision | Choice | Rationale | Revisable? | Made By |
-  |---|------|-------|----------|--------|-----------|------------|---------|
-  | D001 | M001 | arch | Use REST API | REST | Simpler | Yes | human |
-  `;
-
-    fs.writeFileSync(mdPath, tableContent, 'utf-8');
-
-    try {
-      const result = await saveDecisionToDb({
-        scope: 'testing',
-        decision: 'Use Vitest',
-        choice: 'Vitest',
-        rationale: 'Fast',
-        when_context: 'M001',
-      }, tmpDir);
-
-      // The pre-existing table decision was NOT in DB, so it won't appear after regen.
-      // But the new decision should be there.
-      assert.deepStrictEqual(result.id, 'D001', 'gets D001 since DB was empty');
-
-      const afterContent = fs.readFileSync(mdPath, 'utf-8');
-      // Table-format file gets fully regenerated — this is the normal path
-      assert.ok(
-        afterContent.includes('# Decisions Register'),
-        'table-format file still has header after save',
-      );
-      assert.ok(
-        afterContent.includes('Use Vitest'),
-        'new decision present in regenerated table',
-      );
-    } finally {
-      closeDatabase();
-      cleanupDir(tmpDir);
-    }
-  });
-
-  test('saveDecisionToDb with no existing DECISIONS.md creates table', async () => {
-    const tmpDir = makeTmpDir();
-    const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
-    const mdPath = path.join(tmpDir, '.gsd', 'DECISIONS.md');
-    openDatabase(dbPath);
-
-    // No DECISIONS.md exists at all
-    assert.ok(!fs.existsSync(mdPath), 'DECISIONS.md does not exist initially');
-
-    try {
-      const result = await saveDecisionToDb({
-        scope: 'arch',
-        decision: 'Brand new decision',
-        choice: 'Option A',
-        rationale: 'Best fit',
-      }, tmpDir);
-
-      assert.deepStrictEqual(result.id, 'D001', 'first decision gets D001');
-      assert.ok(fs.existsSync(mdPath), 'DECISIONS.md created');
-
-      const content = fs.readFileSync(mdPath, 'utf-8');
-      assert.ok(content.includes('# Decisions Register'), 'new file has header');
-      assert.ok(content.includes('Brand new decision'), 'new file has decision');
-    } finally {
-      closeDatabase();
-      cleanupDir(tmpDir);
-    }
-  });
-
-  // ═══════════════════════════════════════════════════════════════════════════
-
-});