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

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

@@ -0,0 +1,175 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { closeDatabase, openDatabase } from '../gsd-db.ts';
+import { applyMemoryActions, createMemory, supersedeMemory } from '../memory-store.ts';
+import {
+  createMemoryRelation,
+  isValidRelation,
+  listRelationsFor,
+  removeMemoryRelationsFor,
+  traverseGraph,
+  VALID_RELATIONS,
+} from '../memory-relations.ts';
+import { executeGsdGraph } from '../tools/memory-tools.ts';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Validation
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-relations: isValidRelation recognises the canonical set', () => {
+  for (const rel of VALID_RELATIONS) {
+    assert.ok(isValidRelation(rel));
+  }
+  assert.equal(isValidRelation('bogus'), false);
+  assert.equal(isValidRelation(null), false);
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// createMemoryRelation
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-relations: createMemoryRelation round-trips', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'architecture', content: 'auth lives in src/auth' });
+  createMemory({ category: 'pattern', content: 'jwt tokens signed with HS256' });
+
+  const ok = createMemoryRelation('MEM001', 'MEM002', 'elaborates', 0.9);
+  assert.equal(ok, true);
+
+  const relations = listRelationsFor('MEM001');
+  assert.equal(relations.length, 1);
+  assert.equal(relations[0].from, 'MEM001');
+  assert.equal(relations[0].to, 'MEM002');
+  assert.equal(relations[0].rel, 'elaborates');
+  assert.equal(relations[0].confidence, 0.9);
+
+  closeDatabase();
+});
+
+test('memory-relations: rejects self-loops and unknown memories', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'gotcha', content: 'only one memory exists' });
+
+  assert.equal(createMemoryRelation('MEM001', 'MEM001', 'related_to'), false);
+  assert.equal(createMemoryRelation('MEM001', 'MEM999', 'related_to'), false);
+  assert.equal(createMemoryRelation('MEM001', 'MEM002', 'bogus-rel' as never), false);
+
+  closeDatabase();
+});
+
+test('memory-relations: duplicate (from, to, rel) upserts instead of erroring', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'pattern', content: 'A' });
+  createMemory({ category: 'pattern', content: 'B' });
+
+  assert.equal(createMemoryRelation('MEM001', 'MEM002', 'related_to', 0.7), true);
+  assert.equal(createMemoryRelation('MEM001', 'MEM002', 'related_to', 0.9), true);
+
+  const relations = listRelationsFor('MEM001');
+  assert.equal(relations.length, 1);
+  assert.equal(relations[0].confidence, 0.9);
+
+  closeDatabase();
+});
+
+test('memory-relations: removeMemoryRelationsFor wipes both directions', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'pattern', content: 'A' });
+  createMemory({ category: 'pattern', content: 'B' });
+  createMemory({ category: 'pattern', content: 'C' });
+  createMemoryRelation('MEM001', 'MEM002', 'related_to');
+  createMemoryRelation('MEM003', 'MEM002', 'elaborates');
+
+  removeMemoryRelationsFor('MEM002');
+
+  assert.equal(listRelationsFor('MEM001').length, 0);
+  assert.equal(listRelationsFor('MEM002').length, 0);
+  assert.equal(listRelationsFor('MEM003').length, 0);
+
+  closeDatabase();
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// LINK action via applyMemoryActions
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-relations: applyMemoryActions processes LINK actions', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'architecture', content: 'core lives in src/core' });
+  createMemory({ category: 'pattern', content: 'events flow through EventEmitter' });
+
+  applyMemoryActions([
+    { action: 'LINK', from: 'MEM001', to: 'MEM002', rel: 'related_to', confidence: 0.75 },
+    // unknown rel type — should be skipped silently
+    { action: 'LINK', from: 'MEM001', to: 'MEM002', rel: 'nonsense-rel' as never },
+  ]);
+
+  const relations = listRelationsFor('MEM001');
+  assert.equal(relations.length, 1);
+  assert.equal(relations[0].rel, 'related_to');
+
+  closeDatabase();
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// traverseGraph + gsd_graph tool
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-relations: traverseGraph walks multi-hop edges', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'pattern', content: 'A' });
+  createMemory({ category: 'pattern', content: 'B' });
+  createMemory({ category: 'pattern', content: 'C' });
+  createMemoryRelation('MEM001', 'MEM002', 'related_to');
+  createMemoryRelation('MEM002', 'MEM003', 'depends_on');
+
+  const hop1 = traverseGraph('MEM001', 1);
+  assert.equal(hop1.nodes.length, 2);
+  assert.equal(hop1.edges.filter((e) => e.rel !== 'supersedes').length, 1);
+
+  const hop2 = traverseGraph('MEM001', 2);
+  assert.equal(hop2.nodes.length, 3);
+  assert.equal(hop2.edges.filter((e) => e.rel !== 'supersedes').length, 2);
+
+  closeDatabase();
+});
+
+test('memory-relations: traverseGraph still reports supersedes edges', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'convention', content: 'old style' });
+  createMemory({ category: 'convention', content: 'new style' });
+  supersedeMemory('MEM001', 'MEM002');
+
+  const graph = traverseGraph('MEM001', 1);
+  const ids = graph.nodes.map((n) => n.id).sort();
+  assert.deepEqual(ids, ['MEM001', 'MEM002']);
+  assert.ok(graph.edges.some((e) => e.rel === 'supersedes' && e.from === 'MEM001' && e.to === 'MEM002'));
+
+  closeDatabase();
+});
+
+test('memory-tools: gsd_graph returns LINK edges and filters by rel', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'pattern', content: 'alpha' });
+  createMemory({ category: 'pattern', content: 'beta' });
+  createMemory({ category: 'pattern', content: 'gamma' });
+  createMemoryRelation('MEM001', 'MEM002', 'related_to');
+  createMemoryRelation('MEM001', 'MEM003', 'contradicts');
+
+  const all = executeGsdGraph({ mode: 'query', memoryId: 'MEM001', depth: 1 });
+  assert.ok(!all.isError);
+  const allEdges = all.details.edges as Array<{ rel: string }>;
+  const relTypes = new Set(allEdges.map((e) => e.rel));
+  assert.ok(relTypes.has('related_to'));
+  assert.ok(relTypes.has('contradicts'));
+
+  const filtered = executeGsdGraph({ mode: 'query', memoryId: 'MEM001', depth: 1, rel: 'related_to' });
+  assert.ok(!filtered.isError);
+  const fEdges = filtered.details.edges as Array<{ rel: string; to: string }>;
+  assert.equal(fEdges.length, 1);
+  assert.equal(fEdges[0].rel, 'related_to');
+  assert.equal(fEdges[0].to, 'MEM002');
+
+  closeDatabase();
+});

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

@@ -323,9 +323,9 @@ test('memory-store: schema includes memories table', () => {
   const viewCount = adapter.prepare('SELECT count(*) as cnt FROM active_memories').get();
   assert.deepStrictEqual(viewCount?.['cnt'], 0, 'active_memories view should exist');
 
-  // Verify schema version is 17 (ADR-011 P2 escalation columns included)
+  // Verify schema version is 20 (memory Phase 4 relations included)
   const version = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.['v'], 17, 'schema version should be 17');
+  assert.deepStrictEqual(version?.['v'], 20, 'schema version should be 20');
 
   closeDatabase();
 });

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

@@ -0,0 +1,295 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { closeDatabase, openDatabase } from '../gsd-db.ts';
+import { createMemory, supersedeMemory } from '../memory-store.ts';
+import {
+  executeGsdGraph,
+  executeMemoryCapture,
+  executeMemoryQuery,
+} from '../tools/memory-tools.ts';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// capture_thought
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-tools: capture_thought creates a memory with a MEM id', () => {
+  openDatabase(':memory:');
+
+  const result = executeMemoryCapture({
+    category: 'gotcha',
+    content: 'sql.js FTS5 virtual tables need explicit triggers.',
+  });
+
+  assert.ok(!result.isError, 'capture should not error');
+  assert.equal(result.details.operation, 'memory_capture');
+  assert.equal(result.details.id, 'MEM001');
+  assert.equal(result.details.category, 'gotcha');
+  assert.equal(result.details.confidence, 0.8);
+
+  closeDatabase();
+});
+
+test('memory-tools: capture_thought rejects invalid category', () => {
+  openDatabase(':memory:');
+
+  const result = executeMemoryCapture({
+    category: 'opinion', // not in the allow-list
+    content: 'some content',
+  });
+
+  assert.ok(result.isError, 'invalid category should error');
+  assert.equal(result.details.error, 'invalid_category');
+
+  closeDatabase();
+});
+
+test('memory-tools: capture_thought rejects missing fields', () => {
+  openDatabase(':memory:');
+
+  const empty = executeMemoryCapture({ category: '', content: '' });
+  assert.ok(empty.isError, 'missing fields should error');
+  assert.equal(empty.details.error, 'missing_fields');
+
+  closeDatabase();
+});
+
+test('memory-tools: capture_thought clamps confidence to the 0.1–0.99 range', () => {
+  openDatabase(':memory:');
+
+  const hi = executeMemoryCapture({
+    category: 'convention',
+    content: 'clamp test high',
+    confidence: 42,
+  });
+  assert.ok(!hi.isError);
+  assert.equal(hi.details.confidence, 0.99);
+
+  const lo = executeMemoryCapture({
+    category: 'convention',
+    content: 'clamp test low',
+    confidence: -5,
+  });
+  assert.ok(!lo.isError);
+  assert.equal(lo.details.confidence, 0.1);
+
+  closeDatabase();
+});
+
+test('memory-tools: capture_thought fails gracefully when DB is closed', () => {
+  closeDatabase();
+
+  const result = executeMemoryCapture({
+    category: 'gotcha',
+    content: 'db closed',
+  });
+
+  assert.ok(result.isError, 'db-closed capture should error');
+  assert.equal(result.details.error, 'db_unavailable');
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// memory_query
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-tools: memory_query keyword-matches and ranks by confidence × hits', () => {
+  openDatabase(':memory:');
+
+  createMemory({ category: 'gotcha', content: 'sql.js FTS5 triggers must mirror insert/update/delete', confidence: 0.9 });
+  createMemory({ category: 'pattern', content: 'use prepared statements for hot paths', confidence: 0.7 });
+  createMemory({ category: 'convention', content: 'prefer async iterators for streaming', confidence: 0.8 });
+
+  const result = executeMemoryQuery({ query: 'sql triggers', k: 5 });
+  assert.ok(!result.isError);
+  const hits = result.details.hits as Array<{ id: string; content: string; reason: string }>;
+  assert.ok(hits.length >= 1, 'should return at least one keyword hit');
+  assert.equal(hits[0].id, 'MEM001', 'most-relevant memory should rank first');
+  assert.equal(hits[0].reason, 'keyword');
+
+  closeDatabase();
+});
+
+test('memory-tools: memory_query returns empty list when no keywords match', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'gotcha', content: 'unrelated content' });
+
+  const result = executeMemoryQuery({ query: 'totally different phrase', k: 5 });
+  assert.ok(!result.isError);
+  const hits = result.details.hits as unknown[];
+  assert.equal(hits.length, 0);
+  assert.equal(result.content[0].text, 'No matching memories.');
+
+  closeDatabase();
+});
+
+test('memory-tools: memory_query with empty query returns ranked memories', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'gotcha', content: 'first', confidence: 0.95 });
+  createMemory({ category: 'pattern', content: 'second', confidence: 0.5 });
+
+  const result = executeMemoryQuery({ query: '   ' });
+  assert.ok(!result.isError);
+  const hits = result.details.hits as Array<{ id: string; reason: string }>;
+  assert.equal(hits.length, 2);
+  assert.equal(hits[0].id, 'MEM001', 'higher-confidence memory ranks first under empty query');
+  assert.equal(hits[0].reason, 'ranked');
+
+  closeDatabase();
+});
+
+test('memory-tools: memory_query filters by category', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'gotcha', content: 'db pragma needed' });
+  createMemory({ category: 'pattern', content: 'db pragma needed' });
+
+  const result = executeMemoryQuery({ query: 'db pragma', category: 'gotcha' });
+  assert.ok(!result.isError);
+  const hits = result.details.hits as Array<{ id: string; category: string }>;
+  assert.equal(hits.length, 1);
+  assert.equal(hits[0].category, 'gotcha');
+
+  closeDatabase();
+});
+
+test('memory-tools: memory_query filters by scope and tag', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'gotcha', content: 'shared fact', scope: 'project', tags: ['db', 'sqlite'] });
+  createMemory({ category: 'gotcha', content: 'global fact', scope: 'global', tags: ['db'] });
+  createMemory({ category: 'gotcha', content: 'other scope', scope: 'project', tags: ['net'] });
+
+  const projectScoped = executeMemoryQuery({ query: 'fact', scope: 'project' });
+  assert.ok(!projectScoped.isError);
+  const projectHits = projectScoped.details.hits as Array<{ id: string }>;
+  assert.equal(projectHits.length, 1);
+  assert.equal(projectHits[0].id, 'MEM001');
+
+  const tagged = executeMemoryQuery({ query: 'fact', tag: 'sqlite' });
+  assert.ok(!tagged.isError);
+  const taggedHits = tagged.details.hits as Array<{ id: string }>;
+  assert.equal(taggedHits.length, 1);
+  assert.equal(taggedHits[0].id, 'MEM001');
+
+  closeDatabase();
+});
+
+test('memory-tools: capture_thought stores scope and tags', () => {
+  openDatabase(':memory:');
+  const result = executeMemoryCapture({
+    category: 'architecture',
+    content: 'use WAL journaling by default',
+    scope: 'global',
+    tags: ['sqlite', 'wal'],
+  });
+  assert.ok(!result.isError);
+  assert.equal(result.details.scope, 'global');
+  assert.deepEqual(result.details.tags, ['sqlite', 'wal']);
+
+  const lookup = executeMemoryQuery({ query: 'WAL', scope: 'global', tag: 'wal' });
+  const hits = lookup.details.hits as Array<{ id: string }>;
+  assert.equal(hits.length, 1);
+  assert.equal(hits[0].id, 'MEM001');
+
+  closeDatabase();
+});
+
+test('memory-tools: memory_query clamps k to the 1–50 range', () => {
+  openDatabase(':memory:');
+  for (let i = 0; i < 10; i++) {
+    createMemory({ category: 'pattern', content: `pattern ${i}` });
+  }
+
+  const tooLow = executeMemoryQuery({ query: 'pattern', k: 0 });
+  assert.ok(!tooLow.isError);
+  assert.equal((tooLow.details.hits as unknown[]).length, 1);
+
+  const sane = executeMemoryQuery({ query: 'pattern', k: 999 });
+  assert.ok(!sane.isError);
+  assert.equal((sane.details.hits as unknown[]).length, 10);
+
+  closeDatabase();
+});
+
+test('memory-tools: memory_query can reinforce returned hits', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'gotcha', content: 'needs reinforcement' });
+
+  executeMemoryQuery({ query: 'reinforcement', reinforce_hits: true });
+  const follow = executeMemoryQuery({ query: 'reinforcement' });
+  const hits = follow.details.hits as Array<{ hit_count: number }>;
+  assert.equal(hits.length, 1);
+  assert.ok(hits[0].hit_count >= 1, 'hit_count should increment on reinforce');
+
+  closeDatabase();
+});
+
+test('memory-tools: memory_query ignores superseded memories by default', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'convention', content: 'old way of doing X' });
+  createMemory({ category: 'convention', content: 'new way of doing X' });
+  supersedeMemory('MEM001', 'MEM002');
+
+  const active = executeMemoryQuery({ query: 'doing' });
+  const activeHits = active.details.hits as Array<{ id: string }>;
+  assert.equal(activeHits.length, 1);
+  assert.equal(activeHits[0].id, 'MEM002');
+
+  const withSuperseded = executeMemoryQuery({ query: 'doing', include_superseded: true });
+  const allHits = withSuperseded.details.hits as Array<{ id: string }>;
+  assert.equal(allHits.length, 2);
+
+  closeDatabase();
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// gsd_graph
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-tools: gsd_graph build acknowledges request', () => {
+  openDatabase(':memory:');
+  const result = executeGsdGraph({ mode: 'build' });
+  assert.ok(!result.isError);
+  assert.equal(result.details.operation, 'gsd_graph');
+  assert.equal(result.details.mode, 'build');
+  closeDatabase();
+});
+
+test('memory-tools: gsd_graph query rejects missing memoryId', () => {
+  openDatabase(':memory:');
+  const result = executeGsdGraph({ mode: 'query' });
+  assert.ok(result.isError);
+  assert.equal(result.details.error, 'missing_memory_id');
+  closeDatabase();
+});
+
+test('memory-tools: gsd_graph query returns node + supersedes edge', () => {
+  openDatabase(':memory:');
+  createMemory({ category: 'convention', content: 'first' });
+  createMemory({ category: 'convention', content: 'second' });
+  supersedeMemory('MEM001', 'MEM002');
+
+  const result = executeGsdGraph({ mode: 'query', memoryId: 'MEM001', depth: 1 });
+  assert.ok(!result.isError);
+  const nodes = result.details.nodes as Array<{ id: string }>;
+  const edges = result.details.edges as Array<{ from: string; to: string; rel: string }>;
+
+  const nodeIds = nodes.map((n) => n.id).sort();
+  assert.deepEqual(nodeIds, ['MEM001', 'MEM002']);
+  assert.ok(edges.some((e) => e.from === 'MEM001' && e.to === 'MEM002' && e.rel === 'supersedes'));
+
+  closeDatabase();
+});
+
+test('memory-tools: gsd_graph query returns empty when memoryId does not exist', () => {
+  openDatabase(':memory:');
+  const result = executeGsdGraph({ mode: 'query', memoryId: 'MEM999' });
+  assert.ok(!result.isError, 'missing memory is not an error, just empty');
+  assert.equal((result.details.nodes as unknown[]).length, 0);
+  closeDatabase();
+});
+
+test('memory-tools: gsd_graph errors when DB is closed', () => {
+  closeDatabase();
+  const result = executeGsdGraph({ mode: 'query', memoryId: 'MEM001' });
+  assert.ok(result.isError);
+  assert.equal(result.details.error, 'db_unavailable');
+});

package/src/resources/extensions/gsd/tests/pre-execution-checks.test.ts

@@ -1579,3 +1579,69 @@ describe("checkTaskOrdering directory inputs (#4446)", () => {
     );
   });
 });
+
+describe("checkFilePathConsistency self-referential inputs (#4459)", () => {
+  test("input that is also in the same task's expected_output is not blocking when missing on disk", (t) => {
+    const tempDir = join(tmpdir(), `pre-exec-self-output-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const tasks = [
+      createTask({
+        id: "T02",
+        sequence: 0,
+        inputs: ["src/components/email/SnoozePopover.jsx"],
+        expected_output: ["src/components/email/SnoozePopover.jsx"],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.deepEqual(
+      results,
+      [],
+      "File declared as both input and expected_output of the same task should not block — the task itself produces it",
+    );
+  });
+
+  test("input missing from disk, missing from prior outputs, and missing from own expected_output still blocks", (t) => {
+    const tempDir = join(tmpdir(), `pre-exec-self-output-missing-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const tasks = [
+      createTask({
+        id: "T02",
+        sequence: 0,
+        inputs: ["src/components/email/SnoozePopover.jsx"],
+        expected_output: ["src/other/unrelated.jsx"],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.equal(results.length, 1, "Genuinely missing input should still be reported");
+    assert.equal(results[0].blocking, true);
+    assert.equal(results[0].target, "src/components/email/SnoozePopover.jsx");
+  });
+
+  test("self-output exemption matches across path normalization (./ prefix)", (t) => {
+    const tempDir = join(tmpdir(), `pre-exec-self-output-norm-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const tasks = [
+      createTask({
+        id: "T02",
+        sequence: 0,
+        inputs: ["./src/generated.ts"],
+        expected_output: ["src/generated.ts"],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.deepEqual(
+      results,
+      [],
+      "./src/generated.ts and src/generated.ts should compare equal after normalization",
+    );
+  });
+});