gsd-pi 2.44.0-dev.62b5d6c → 2.44.0-dev.73f2fd5

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

@@ -1,4 +1,5 @@
-import { createTestContext } from './test-helpers.ts';
+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';
@@ -13,8 +14,6 @@ import {
   saveDecisionToDb,
 } from '../db-writer.ts';
 
-const { assertEq, assertTrue, report } = createTestContext();
-
 // ═══════════════════════════════════════════════════════════════════════════
 // Helpers
 // ═══════════════════════════════════════════════════════════════════════════
@@ -35,206 +34,199 @@ function cleanupDir(dir: string): void {
 // Bug reproduction: freeform DECISIONS.md content destroyed (#2301)
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n── 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);
-  assertEq(parsed.length, 0, 'freeform content yields zero parsed decisions (expected — it is not a table)');
-}
-
-console.log('\n── saveDecisionToDb destroys freeform DECISIONS.md content ──');
-
-{
-  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);
-
-    assertEq(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
-    assertTrue(
-      afterContent.includes('microservices architecture'),
-      'freeform architecture section preserved after saveDecisionToDb',
-    );
-    assertTrue(
-      afterContent.includes('PostgreSQL was chosen'),
-      'freeform database section preserved after saveDecisionToDb',
-    );
-    assertTrue(
-      afterContent.includes('Kubernetes for orchestration'),
-      'freeform deployment section preserved after saveDecisionToDb',
-    );
-
-    // The new decision MUST also be present
-    assertTrue(
-      afterContent.includes('D001'),
-      'new decision D001 present in file',
-    );
-    assertTrue(
-      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);
-
-    assertEq(result2.id, 'D002', 'second decision ID assigned correctly');
-
-    const afterContent2 = fs.readFileSync(mdPath, 'utf-8');
-
-    assertTrue(
-      afterContent2.includes('microservices architecture'),
-      'freeform content still preserved after second save',
-    );
-    assertTrue(
-      afterContent2.includes('D001'),
-      'first decision still present after second save',
-    );
-    assertTrue(
-      afterContent2.includes('D002'),
-      'second decision present after second save',
-    );
-    assertTrue(
-      afterContent2.includes('Use GitHub Actions for CI'),
-      'second decision text present in file',
-    );
-  } finally {
-    closeDatabase();
-    cleanupDir(tmpDir);
-  }
-}
-
-console.log('\n── saveDecisionToDb with table-format DECISIONS.md still regenerates normally ──');
-
-{
-  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.
-    assertEq(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
-    assertTrue(
-      afterContent.includes('# Decisions Register'),
-      'table-format file still has header after save',
-    );
-    assertTrue(
-      afterContent.includes('Use Vitest'),
-      'new decision present in regenerated table',
-    );
-  } finally {
-    closeDatabase();
-    cleanupDir(tmpDir);
-  }
-}
-
-console.log('\n── saveDecisionToDb with no existing DECISIONS.md creates table ──');
-
-{
-  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
-  assertTrue(!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);
-
-    assertEq(result.id, 'D001', 'first decision gets D001');
-    assertTrue(fs.existsSync(mdPath), 'DECISIONS.md created');
-
-    const content = fs.readFileSync(mdPath, 'utf-8');
-    assertTrue(content.includes('# Decisions Register'), 'new file has header');
-    assertTrue(content.includes('Brand new decision'), 'new file has decision');
-  } finally {
-    closeDatabase();
-    cleanupDir(tmpDir);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-
-report();
+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);
+    }
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+
+});

package/src/resources/extensions/gsd/tests/git-locale.test.ts

@@ -1,3 +1,5 @@
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 /**
  * Regression tests for #1997: git locale not forced to C.
  *
@@ -13,10 +15,6 @@ import { execFileSync } from "node:child_process";
 import { GIT_NO_PROMPT_ENV } from "../git-constants.ts";
 import { nativeAddAllWithExclusions } from "../native-git-bridge.ts";
 import { RUNTIME_EXCLUSION_PATHS } from "../git-service.ts";
-import { createTestContext } from "./test-helpers.ts";
-
-const { assertEq, assertTrue, report } = createTestContext();
-
 function git(cwd: string, ...args: string[]): string {
   return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }
@@ -39,27 +37,24 @@ function createFile(base: string, relPath: string, content: string): void {
   writeFileSync(full, content);
 }
 
-async function main(): Promise<void> {
+describe('git-locale', async () => {
   // ─── GIT_NO_PROMPT_ENV includes LC_ALL=C ─────────────────────────────
 
-  console.log("\n=== GIT_NO_PROMPT_ENV includes LC_ALL=C ===");
 
-  assertEq(
+  assert.deepStrictEqual(
     GIT_NO_PROMPT_ENV.LC_ALL,
     "C",
     "GIT_NO_PROMPT_ENV must set LC_ALL to 'C' to force English git output"
   );
 
-  assertTrue(
+  assert.ok(
     "GIT_TERMINAL_PROMPT" in GIT_NO_PROMPT_ENV,
     "GIT_NO_PROMPT_ENV still contains GIT_TERMINAL_PROMPT"
   );
 
   // ─── nativeAddAllWithExclusions: non-English locale does not throw ───
 
-  console.log("\n=== nativeAddAllWithExclusions: non-English locale does not throw ===");
-
-  {
+  test('nativeAddAllWithExclusions: non-English locale does not throw', () => {
     // Simulate what happens on a German system: .gsd is gitignored,
     // exclusion pathspecs trigger an advisory warning exit code 1.
     // With LC_ALL=C the English stderr guard should match and suppress.
@@ -89,22 +84,20 @@ async function main(): Promise<void> {
     if (origLang !== undefined) process.env.LANG = origLang;
     else delete process.env.LANG;
 
-    assertTrue(
+    assert.ok(
       !threw,
       "nativeAddAllWithExclusions must not throw on non-English locale when .gsd is gitignored (#1997)"
     );
 
     const staged = git(repo, "diff", "--cached", "--name-only");
-    assertTrue(staged.includes("src/app.ts"), "real file staged despite German locale");
+    assert.ok(staged.includes("src/app.ts"), "real file staged despite German locale");
 
     rmSync(repo, { recursive: true, force: true });
-  }
+  });
 
   // ─── nativeMergeSquash: env is passed (merge-squash stderr is English) ─
 
-  console.log("\n=== nativeMergeSquash fallback uses GIT_NO_PROMPT_ENV ===");
-
-  {
+  test('nativeMergeSquash fallback uses GIT_NO_PROMPT_ENV', () => {
     // We verify indirectly: the source code must pass env: GIT_NO_PROMPT_ENV.
     // Read the source and check for the pattern. This is a static check.
     const src = readFileSync(
@@ -114,20 +107,13 @@ async function main(): Promise<void> {
 
     // Find the nativeMergeSquash function and check it uses GIT_NO_PROMPT_ENV
     const fnStart = src.indexOf("export function nativeMergeSquash");
-    assertTrue(fnStart !== -1, "nativeMergeSquash function exists in source");
+    assert.ok(fnStart !== -1, "nativeMergeSquash function exists in source");
 
     const fnBody = src.slice(fnStart, src.indexOf("\nexport function", fnStart + 1));
     const hasEnv = fnBody.includes("env: GIT_NO_PROMPT_ENV");
-    assertTrue(
+    assert.ok(
       hasEnv,
       "nativeMergeSquash fallback must pass env: GIT_NO_PROMPT_ENV to execFileSync (#1997)"
     );
-  }
-
-  report();
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
+  });
 });