gsd-pi 2.75.0-dev.b6ad8c5f7 → 2.75.0-dev.e41b70b10

package/src/resources/extensions/gsd/tests/integration/doctor-git-symlink-cwd.test.ts

@@ -0,0 +1,79 @@
+import assert from "node:assert/strict";
+import { execSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+
+import { runGSDDoctor } from "../../doctor.ts";
+
+function run(cmd: string, cwd: string): string {
+  return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createRepoWithCompletedMilestone(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-git-symlink-cwd-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+
+  const milestoneDir = join(dir, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(join(milestoneDir, "ROADMAP.md"), `---
+id: M001
+title: "Test Milestone"
+---
+
+# M001: Test Milestone
+
+## Vision
+Test
+
+## Success Criteria
+- Done
+
+## Slices
+- [x] **S01: Test slice** \`risk:low\` \`depends:[]\`
+  > After this: done
+
+## Boundary Map
+_None_
+`);
+
+  run("git add -A", dir);
+  run("git commit -m \"add milestone\"", dir);
+
+  return dir;
+}
+
+test("doctor removes orphaned milestone worktree when cwd uses a symlink alias", { skip: process.platform === "win32" }, async (t) => {
+  const previousCwd = process.cwd();
+  const dir = createRepoWithCompletedMilestone();
+  const alias = join(tmpdir(), `doc-git-alias-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+
+  t.after(() => {
+    try { process.chdir(previousCwd); } catch { process.chdir(tmpdir()); }
+    rmSync(alias, { recursive: true, force: true });
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
+  run("git worktree add -b milestone/M001 .gsd/worktrees/M001", dir);
+
+  symlinkSync(dir, alias);
+  process.chdir(join(alias, ".gsd", "worktrees", "M001"));
+
+  const fixed = await runGSDDoctor(dir, { fix: true, isolationMode: "worktree" });
+  assert.ok(
+    fixed.fixesApplied.some(f => f.includes("removed orphaned worktree")),
+    `removes orphaned worktree even when cwd uses a symlink alias (got: ${JSON.stringify(fixed.fixesApplied)})`,
+  );
+
+  const wtList = run("git worktree list", dir);
+  assert.ok(!wtList.includes("milestone/M001"), "worktree removed after symlink-cwd fix");
+});

package/src/resources/extensions/gsd/tests/md-importer.test.ts

@@ -363,7 +363,7 @@ test('md-importer: schema v1→v2 migration', () => {
   openDatabase(':memory:');
   const adapter = _getAdapter();
   const version = adapter?.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.v, 17, 'new DB should be at schema version 17');
+  assert.deepStrictEqual(version?.v, 20, 'new DB should be at schema version 20');
 
   // Artifacts table should exist
   const tableCheck = adapter?.prepare("SELECT count(*) as c FROM sqlite_master WHERE type='table' AND name='artifacts'").get();

package/src/resources/extensions/gsd/tests/memory-embeddings.test.ts

@@ -0,0 +1,213 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { _getAdapter, closeDatabase, openDatabase } from '../gsd-db.ts';
+import { createMemory, queryMemoriesRanked, supersedeMemory } from '../memory-store.ts';
+import {
+  cosineSimilarity,
+  embedMemories,
+  getEmbeddingForMemory,
+  loadAllEmbeddings,
+  packFloat32,
+  removeEmbedding,
+  saveEmbedding,
+  unpackFloat32,
+} from '../memory-embeddings.ts';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Float32 packing + cosine math
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-embeddings: packFloat32 / unpackFloat32 round-trip', () => {
+  const vec = new Float32Array([0.1, -0.5, 0.25, 0.75]);
+  const packed = packFloat32(vec);
+  const restored = unpackFloat32(packed);
+  assert.ok(restored);
+  assert.equal(restored!.length, vec.length);
+  for (let i = 0; i < vec.length; i++) {
+    assert.ok(Math.abs(restored![i] - vec[i]) < 1e-6);
+  }
+});
+
+test('memory-embeddings: cosineSimilarity identities', () => {
+  const a = new Float32Array([1, 0, 0]);
+  const b = new Float32Array([1, 0, 0]);
+  const c = new Float32Array([0, 1, 0]);
+  assert.ok(Math.abs(cosineSimilarity(a, b) - 1) < 1e-6);
+  assert.ok(Math.abs(cosineSimilarity(a, c)) < 1e-6);
+  assert.equal(cosineSimilarity(new Float32Array([]), new Float32Array([])), 0);
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory_embeddings table round-trip
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-embeddings: saveEmbedding then getEmbeddingForMemory', () => {
+  openDatabase(':memory:');
+  const id = createMemory({ category: 'pattern', content: 'embedding persistence test' });
+  assert.ok(id);
+
+  const vec = new Float32Array([0.1, 0.2, 0.3]);
+  assert.ok(saveEmbedding(id!, vec, 'test-model'));
+
+  const row = getEmbeddingForMemory(id!);
+  assert.ok(row);
+  assert.equal(row!.model, 'test-model');
+  assert.equal(row!.dim, 3);
+  assert.equal(row!.vector.length, 3);
+
+  assert.ok(removeEmbedding(id!));
+  assert.equal(getEmbeddingForMemory(id!), null);
+
+  closeDatabase();
+});
+
+test('memory-embeddings: loadAllEmbeddings skips superseded memories', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'pattern', content: 'mem A' });
+  createMemory({ category: 'pattern', content: 'mem B' });
+  saveEmbedding('MEM001', new Float32Array([1, 0, 0]), 'm');
+  saveEmbedding('MEM002', new Float32Array([0, 1, 0]), 'm');
+
+  const all = loadAllEmbeddings();
+  assert.equal(all.length, 2);
+
+  // supersede MEM001
+  supersedeMemory('MEM001', 'MEM002');
+
+  const remaining = loadAllEmbeddings();
+  assert.equal(remaining.length, 1);
+  assert.equal(remaining[0].memoryId, 'MEM002');
+
+  closeDatabase();
+});
+
+test('memory-embeddings: embedMemories returns 0 when embedFn is null', async () => {
+  const n = await embedMemories([{ id: 'MEM001', content: 'x' }], null, 'none');
+  assert.equal(n, 0);
+});
+
+test('memory-embeddings: embedMemories persists fetched vectors', async () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'pattern', content: 'first' });
+  createMemory({ category: 'pattern', content: 'second' });
+
+  const fn = async (texts: string[]): Promise<Float32Array[]> =>
+    texts.map((_, i) => new Float32Array([i, i + 1, i + 2]));
+
+  const count = await embedMemories(
+    [
+      { id: 'MEM001', content: 'first' },
+      { id: 'MEM002', content: 'second' },
+    ],
+    fn,
+    'mock-embedder',
+  );
+  assert.equal(count, 2);
+
+  const first = getEmbeddingForMemory('MEM001');
+  assert.ok(first);
+  assert.equal(first!.model, 'mock-embedder');
+  assert.equal(first!.vector.length, 3);
+
+  closeDatabase();
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// queryMemoriesRanked + FTS5 keyword path
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-store: queryMemoriesRanked returns keyword hits', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'gotcha', content: 'sql.js FTS5 virtual tables need triggers' });
+  createMemory({ category: 'pattern', content: 'prefer prepared statements for hot paths' });
+  createMemory({ category: 'convention', content: 'atomic writes use tmp + rename' });
+
+  const ranked = queryMemoriesRanked({ query: 'sql triggers', k: 5 });
+  assert.ok(ranked.length >= 1);
+  assert.equal(ranked[0].memory.id, 'MEM001');
+  assert.ok(ranked[0].keywordRank !== null);
+  assert.equal(ranked[0].reason, 'keyword');
+
+  closeDatabase();
+});
+
+test('memory-store: queryMemoriesRanked respects scope + tag filters', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'gotcha', content: 'scoped fact one', scope: 'project', tags: ['a'] });
+  createMemory({ category: 'gotcha', content: 'scoped fact two', scope: 'global', tags: ['a', 'b'] });
+
+  const projectOnly = queryMemoriesRanked({ query: 'scoped fact', scope: 'project' });
+  assert.equal(projectOnly.length, 1);
+  assert.equal(projectOnly[0].memory.scope, 'project');
+
+  const tagged = queryMemoriesRanked({ query: 'scoped fact', tag: 'b' });
+  assert.equal(tagged.length, 1);
+  assert.equal(tagged[0].memory.id, 'MEM002');
+
+  closeDatabase();
+});
+
+test('memory-store: queryMemoriesRanked fuses keyword + semantic hits', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'pattern', content: 'foo bar baz' });
+  createMemory({ category: 'pattern', content: 'completely unrelated' });
+
+  // Embed memory 2 so semantic scoring picks it up even though the keyword
+  // "foo" does not appear in its content.
+  saveEmbedding('MEM001', new Float32Array([1, 0, 0, 0]), 'mock');
+  saveEmbedding('MEM002', new Float32Array([0.9, 0.1, 0, 0]), 'mock');
+
+  const queryVec = new Float32Array([0.95, 0.05, 0, 0]);
+  const ranked = queryMemoriesRanked({ query: 'foo', queryVector: queryVec, k: 5 });
+  const reasons = ranked.map((r) => r.reason);
+  assert.ok(reasons.includes('both') || reasons.includes('keyword'));
+  const ids = ranked.map((r) => r.memory.id);
+  assert.ok(ids.includes('MEM002'), 'semantic-only hit should surface even without keyword match');
+
+  closeDatabase();
+});
+
+test('memory-store: queryMemoriesRanked falls back to ranked listing when query is empty', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'gotcha', content: 'first', confidence: 0.9 });
+  createMemory({ category: 'pattern', content: 'second', confidence: 0.5 });
+
+  const ranked = queryMemoriesRanked({ query: '   ' });
+  assert.equal(ranked.length, 2);
+  assert.equal(ranked[0].memory.id, 'MEM001');
+  assert.equal(ranked[0].reason, 'ranked');
+
+  closeDatabase();
+});
+
+test('memory-store: queryMemoriesRanked excludes superseded by default', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'gotcha', content: 'stale insight' });
+  createMemory({ category: 'gotcha', content: 'fresh insight' });
+
+  supersedeMemory('MEM001', 'MEM002');
+
+  const active = queryMemoriesRanked({ query: 'insight' });
+  assert.ok(active.every((r) => r.memory.superseded_by == null));
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// FTS5 triggers keep memories_fts in sync with memories
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-store schema: memories_fts stays in sync with memories', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'pattern', content: 'alpha beta gamma' });
+  const adapter = _getAdapter();
+  assert.ok(adapter);
+  const fts = adapter!.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='memories_fts'").get();
+  if (!fts) {
+    // Build without FTS5 — skip.
+    closeDatabase();
+    return;
+  }
+  const rows = adapter!.prepare(`SELECT content FROM memories_fts WHERE memories_fts MATCH 'beta'`).all();
+  assert.ok(rows.some((row) => (row['content'] as string).includes('alpha beta gamma')));
+  closeDatabase();
+});

package/src/resources/extensions/gsd/tests/memory-ingest.test.ts

@@ -0,0 +1,153 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { _getAdapter, closeDatabase, openDatabase } from '../gsd-db.ts';
+import {
+  createMemorySource,
+  deleteMemorySource,
+  getMemorySource,
+  hashContent,
+  listMemorySources,
+} from '../memory-source-store.ts';
+import { ingestFile, ingestNote, summarizeIngest } from '../memory-ingest.ts';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-source-store
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-sources: content_hash is stable', () => {
+  const a = hashContent('hello');
+  const b = hashContent('hello');
+  assert.equal(a, b);
+  assert.notEqual(a, hashContent('world'));
+});
+
+test('memory-sources: createMemorySource is idempotent on content_hash', () => {
+  openDatabase(':memory:');
+
+  const first = createMemorySource({
+    kind: 'note',
+    content: 'sql.js FTS5 triggers must be kept in sync with the base table',
+    tags: ['db', 'fts'],
+  });
+  assert.ok(first);
+  assert.equal(first!.duplicate, false);
+
+  const second = createMemorySource({
+    kind: 'note',
+    content: 'sql.js FTS5 triggers must be kept in sync with the base table',
+    tags: ['db', 'fts'],
+  });
+  assert.ok(second);
+  assert.equal(second!.duplicate, true);
+  assert.equal(second!.id, first!.id);
+
+  const sources = listMemorySources();
+  assert.equal(sources.length, 1);
+  assert.equal(sources[0].kind, 'note');
+  assert.deepEqual(sources[0].tags, ['db', 'fts']);
+
+  closeDatabase();
+});
+
+test('memory-sources: getMemorySource and deleteMemorySource round-trip', () => {
+  openDatabase(':memory:');
+
+  const created = createMemorySource({ kind: 'note', content: 'note to delete' });
+  assert.ok(created);
+  const fetched = getMemorySource(created!.id);
+  assert.ok(fetched);
+  assert.equal(fetched!.content, 'note to delete');
+
+  const removed = deleteMemorySource(created!.id);
+  assert.ok(removed);
+  assert.equal(getMemorySource(created!.id), null);
+
+  closeDatabase();
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory-ingest
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-ingest: ingestNote persists a note source', async () => {
+  openDatabase(':memory:');
+
+  const result = await ingestNote('The CAPTURES.md pipeline runs on triage, not dispatch.', null, {
+    tags: ['captures'],
+    scope: 'project',
+    extract: false,
+  });
+
+  assert.ok(result.sourceId.startsWith('SRC-'));
+  assert.equal(result.duplicate, false);
+  assert.equal(result.kind, 'note');
+  assert.equal(result.extracted.length, 0);
+  assert.match(summarizeIngest(result), /no memories extracted/);
+
+  closeDatabase();
+});
+
+test('memory-ingest: ingestNote rejects empty input', async () => {
+  openDatabase(':memory:');
+
+  const result = await ingestNote('   ', null, { extract: false });
+  assert.equal(result.sourceId, '');
+
+  closeDatabase();
+});
+
+test('memory-ingest: ingestNote marks duplicates on replay', async () => {
+  openDatabase(':memory:');
+
+  const first = await ingestNote('same note body', null, { extract: false });
+  const second = await ingestNote('same note body', null, { extract: false });
+  assert.equal(first.sourceId, second.sourceId);
+  assert.equal(second.duplicate, true);
+
+  closeDatabase();
+});
+
+test('memory-ingest: ingestFile persists a file source', async () => {
+  openDatabase(':memory:');
+
+  const dir = mkdtempSync(join(tmpdir(), 'gsd-memory-ingest-'));
+  const file = join(dir, 'sample.md');
+  writeFileSync(file, '# Architecture\n\nWe use SQLite with WAL journaling.', 'utf-8');
+
+  try {
+    const result = await ingestFile(file, null, { tags: ['arch'], extract: false });
+    assert.ok(result.sourceId.startsWith('SRC-'));
+    assert.equal(result.kind, 'file');
+    assert.equal(result.title, 'sample.md');
+    assert.equal(result.uri, file);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+    closeDatabase();
+  }
+});
+
+test('memory-ingest: ingestFile rejects missing paths', async () => {
+  openDatabase(':memory:');
+
+  await assert.rejects(() => ingestFile('/no/such/file/exists.md', null, { extract: false }), /File not found/);
+
+  closeDatabase();
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// schema migration + scope/tags columns on memories
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-store schema: scope and tags columns exist on memories', () => {
+  openDatabase(':memory:');
+  const adapter = _getAdapter();
+  const info = adapter!.prepare('PRAGMA table_info(memories)').all();
+  const names = info.map((row: Record<string, unknown>) => row.name);
+  assert.ok(names.includes('scope'));
+  assert.ok(names.includes('tags'));
+  closeDatabase();
+});

package/src/resources/extensions/gsd/tests/memory-maintenance.test.ts

@@ -0,0 +1,107 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { _getAdapter, closeDatabase, openDatabase } from '../gsd-db.ts';
+import {
+  createMemory,
+  decayStaleMemories,
+  enforceMemoryCap,
+  markUnitProcessed,
+} from '../memory-store.ts';
+import { createMemoryRelation, listRelationsFor } from '../memory-relations.ts';
+import { saveEmbedding, getEmbeddingForMemory } from '../memory-embeddings.ts';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// enforceMemoryCap — cascade cleanup of embeddings and relations
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-cap: supersedes lowest-ranked memories and cascades cleanup', () => {
+  openDatabase(':memory:');
+
+  // Create 6 memories with descending confidence so the first is lowest.
+  createMemory({ category: 'pattern', content: 'weakest', confidence: 0.2 });
+  createMemory({ category: 'pattern', content: 'mid-1', confidence: 0.5 });
+  createMemory({ category: 'pattern', content: 'mid-2', confidence: 0.6 });
+  createMemory({ category: 'pattern', content: 'strong-1', confidence: 0.9 });
+  createMemory({ category: 'pattern', content: 'strong-2', confidence: 0.92 });
+  createMemory({ category: 'pattern', content: 'strongest', confidence: 0.95 });
+
+  saveEmbedding('MEM001', new Float32Array([1, 0, 0]), 'm');
+  saveEmbedding('MEM006', new Float32Array([0, 1, 0]), 'm');
+  createMemoryRelation('MEM001', 'MEM002', 'related_to');
+
+  // Cap at 5 — MEM001 should be superseded and its embedding + relations purged.
+  enforceMemoryCap(5);
+
+  const adapter = _getAdapter();
+  const row = adapter!
+    .prepare("SELECT superseded_by FROM memories WHERE id = 'MEM001'")
+    .get();
+  assert.equal(row?.['superseded_by'], 'CAP_EXCEEDED');
+  assert.equal(getEmbeddingForMemory('MEM001'), null);
+  assert.equal(listRelationsFor('MEM001').length, 0);
+
+  // MEM006 was not victimised — its embedding should still exist.
+  assert.ok(getEmbeddingForMemory('MEM006'));
+
+  closeDatabase();
+});
+
+test('memory-cap: is a no-op when count is already under the cap', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'pattern', content: 'one' });
+  createMemory({ category: 'pattern', content: 'two' });
+
+  enforceMemoryCap(10);
+
+  const adapter = _getAdapter();
+  const count = adapter!
+    .prepare("SELECT count(*) as cnt FROM memories WHERE superseded_by IS NULL")
+    .get();
+  assert.equal(count?.['cnt'], 2);
+
+  closeDatabase();
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// decayStaleMemories — returns list of decayed IDs
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-decay: returns decayed memory IDs', () => {
+  openDatabase(':memory:');
+
+  // Insert processed units — decayStaleMemories needs at least N rows.
+  const now = Date.now();
+  for (let i = 0; i < 21; i++) {
+    markUnitProcessed(`unit/${i}`, `file-${i}`);
+    // small spacing to create deterministic ordering
+    const row = _getAdapter()!
+      .prepare('UPDATE memory_processed_units SET processed_at = :ts WHERE unit_key = :key');
+    row.run({ ':ts': new Date(now + i * 1000).toISOString(), ':key': `unit/${i}` });
+  }
+
+  // Create memory with updated_at in the distant past
+  createMemory({ category: 'pattern', content: 'stale entry', confidence: 0.9 });
+  _getAdapter()!
+    .prepare("UPDATE memories SET updated_at = '2000-01-01T00:00:00Z' WHERE id = 'MEM001'")
+    .run({});
+
+  const decayed = decayStaleMemories(20);
+  assert.ok(decayed.includes('MEM001'));
+
+  // Confidence should have dropped.
+  const row = _getAdapter()!
+    .prepare("SELECT confidence FROM memories WHERE id = 'MEM001'")
+    .get();
+  assert.ok((row?.['confidence'] as number) < 0.9);
+
+  closeDatabase();
+});
+
+test('memory-decay: returns empty when there are fewer processed units than the threshold', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'pattern', content: 'fresh' });
+  const decayed = decayStaleMemories(20);
+  assert.deepEqual(decayed, []);
+  closeDatabase();
+});