@cleocode/core 2026.4.31 → 2026.4.36

package/src/memory/__tests__/auto-extract.test.ts

@@ -1,11 +1,10 @@
 /**
- * Unit tests for auto-extract memory pipeline.
+ * Unit tests for the auto-extract module.
  *
- * extractTaskCompletionMemory and extractSessionEndMemory are disabled no-ops
- * per T523 CA1 specification. Tests verify the no-op contract holds.
- *
- * @task T526
- * @epic T523
+ * The legacy `extractTaskCompletionMemory` and `extractSessionEndMemory`
+ * functions were removed entirely (the LLM extraction gate replaced the
+ * keyword regex in extractFromTranscript). Only `resolveTaskDetails` and
+ * `extractFromTranscript` remain.
  */
 
 import type { Task } from '@cleocode/contracts';
@@ -13,35 +12,25 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 // ---- mocks ----------------------------------------------------------------
 
-vi.mock('../learnings.js', () => ({
-  storeLearning: vi.fn().mockResolvedValue(undefined),
-}));
-
-vi.mock('../patterns.js', () => ({
-  storePattern: vi.fn().mockResolvedValue(undefined),
+vi.mock('../llm-extraction.js', () => ({
+  extractFromTranscript: vi.fn().mockResolvedValue({
+    extractedCount: 0,
+    storedCount: 0,
+    mergedCount: 0,
+    rejectedCount: 0,
+    warnings: [],
+  }),
 }));
 
-vi.mock('../decisions.js', () => ({
-  storeDecision: vi.fn().mockResolvedValue(undefined),
-}));
-
-// Mock getAccessor — should never be called by disabled functions
 vi.mock('../../store/data-accessor.js', () => ({
   getAccessor: vi.fn(),
 }));
 
 // ---- imports after mocks --------------------------------------------------
 
-import type { SessionBridgeData } from '../../sessions/session-memory-bridge.js';
 import { getAccessor } from '../../store/data-accessor.js';
-import {
-  extractSessionEndMemory,
-  extractTaskCompletionMemory,
-  resolveTaskDetails,
-} from '../auto-extract.js';
-import { storeDecision } from '../decisions.js';
-import { storeLearning } from '../learnings.js';
-import { storePattern } from '../patterns.js';
+import { extractFromTranscript, resolveTaskDetails } from '../auto-extract.js';
+import { extractFromTranscript as llmExtractFromTranscript } from '../llm-extraction.js';
 
 // ---- helpers --------------------------------------------------------------
 
@@ -57,16 +46,6 @@ function makeTask(overrides: Partial<Task> & { id: string; title: string }): Tas
   } as Task;
 }
 
-function makeSessionData(overrides: Partial<SessionBridgeData> = {}): SessionBridgeData {
-  return {
-    sessionId: 'S-test-001',
-    scope: 'test scope',
-    tasksCompleted: [],
-    duration: 3600,
-    ...overrides,
-  };
-}
-
 function setupAccessor(tasks: Task[]): void {
   (getAccessor as ReturnType<typeof vi.fn>).mockResolvedValue({
     queryTasks: vi.fn().mockResolvedValue({ tasks, total: tasks.length }),
@@ -83,96 +62,46 @@ beforeEach(() => {
   vi.clearAllMocks();
 });
 
-describe('extractTaskCompletionMemory', () => {
-  it('is a no-op — does not write learnings', async () => {
-    const task = makeTask({ id: 'T001', title: 'Fix auth bug', description: 'Auth was broken' });
-    setupAccessor([task]);
-
-    await extractTaskCompletionMemory('/mock/root', task);
-
-    expect(storeLearning).not.toHaveBeenCalled();
-  });
+describe('extractFromTranscript (wrapper)', () => {
+  it('delegates to the LLM extraction gate for non-empty input', async () => {
+    await extractFromTranscript('/mock/root', 'S-100', 'some transcript content');
 
-  it('is a no-op — does not write dependency learnings', async () => {
-    const task = makeTask({
-      id: 'T002',
-      title: 'Deploy feature',
-      description: 'Deploy the thing',
-      depends: ['T001', 'T003'],
+    expect(llmExtractFromTranscript).toHaveBeenCalledTimes(1);
+    expect(llmExtractFromTranscript).toHaveBeenCalledWith({
+      projectRoot: '/mock/root',
+      sessionId: 'S-100',
+      transcript: 'some transcript content',
     });
-    setupAccessor([task]);
-
-    await extractTaskCompletionMemory('/mock/root', task);
-
-    expect(storeLearning).not.toHaveBeenCalled();
   });
 
-  it('is a no-op — does not write label patterns', async () => {
-    const completedTasks = [
-      makeTask({ id: 'T010', title: 'A', labels: ['bug'] }),
-      makeTask({ id: 'T011', title: 'B', labels: ['bug'] }),
-      makeTask({ id: 'T012', title: 'C', labels: ['bug'] }),
-    ];
-    const trigger = makeTask({ id: 'T013', title: 'D', labels: ['bug'] });
-    setupAccessor([...completedTasks, trigger]);
-
-    await extractTaskCompletionMemory('/mock/root', trigger);
+  it('skips the LLM call when transcript is empty', async () => {
+    await extractFromTranscript('/mock/root', 'S-101', '');
+    expect(llmExtractFromTranscript).not.toHaveBeenCalled();
+  });
 
-    expect(storePattern).not.toHaveBeenCalled();
-    expect(getAccessor).not.toHaveBeenCalled();
+  it('skips the LLM call when transcript is whitespace-only', async () => {
+    await extractFromTranscript('/mock/root', 'S-102', '   \n  \t ');
+    expect(llmExtractFromTranscript).not.toHaveBeenCalled();
   });
 
-  it('resolves to undefined without throwing', async () => {
-    setupAccessor([]);
+  it('swallows errors from the LLM extraction gate', async () => {
+    (llmExtractFromTranscript as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
+      new Error('simulated failure'),
+    );
 
     await expect(
-      extractTaskCompletionMemory('/mock/root', makeTask({ id: 'T099', title: 'X' })),
+      extractFromTranscript('/mock/root', 'S-103', 'meaningful content'),
     ).resolves.toBeUndefined();
   });
-});
 
-describe('extractSessionEndMemory', () => {
-  it('is a no-op — does not write a session decision', async () => {
-    const tasks = [
-      makeTask({ id: 'T001', title: 'Task one' }),
-      makeTask({ id: 'T002', title: 'Task two' }),
-    ];
-    const session = makeSessionData({ sessionId: 'S-001', tasksCompleted: ['T001', 'T002'] });
-
-    await extractSessionEndMemory('/mock/root', session, tasks);
-
-    expect(storeDecision).not.toHaveBeenCalled();
-  });
-
-  it('is a no-op — does not write per-task learnings', async () => {
-    const tasks = [
-      makeTask({ id: 'T001', title: 'Task one', description: 'Desc one' }),
-      makeTask({ id: 'T002', title: 'Task two', description: 'Desc two' }),
-    ];
-    const session = makeSessionData({ sessionId: 'S-002', tasksCompleted: ['T001', 'T002'] });
-
-    await extractSessionEndMemory('/mock/root', session, tasks);
-
-    expect(storeLearning).not.toHaveBeenCalled();
-  });
-
-  it('is a no-op — does not write workflow patterns', async () => {
-    const tasks = [
-      makeTask({ id: 'T001', title: 'A', labels: ['feature'] }),
-      makeTask({ id: 'T002', title: 'B', labels: ['feature'] }),
-    ];
-    const session = makeSessionData({ sessionId: 'S-003', tasksCompleted: ['T001', 'T002'] });
-
-    await extractSessionEndMemory('/mock/root', session, tasks);
-
-    expect(storePattern).not.toHaveBeenCalled();
-  });
-
-  it('resolves to undefined without throwing', async () => {
-    const tasks = [makeTask({ id: 'T001', title: 'X' })];
-    const session = makeSessionData({ tasksCompleted: ['T001'] });
-
-    await expect(extractSessionEndMemory('/mock/root', session, tasks)).resolves.toBeUndefined();
+  it('returns undefined on non-string transcript input', async () => {
+    await expect(
+      extractFromTranscript('/mock/root', 'S-104', null as unknown as string),
+    ).resolves.toBeUndefined();
+    await expect(
+      extractFromTranscript('/mock/root', 'S-104', 123 as unknown as string),
+    ).resolves.toBeUndefined();
+    expect(llmExtractFromTranscript).not.toHaveBeenCalled();
   });
 });
 

package/src/memory/__tests__/brain-automation.test.ts

@@ -460,53 +460,24 @@ describe('ingestStructuredSummary', () => {
 });
 
 // ============================================================================
-// 4. extractFromTranscript (auto-extract.ts)
+// 4. extractFromTranscript (auto-extract.ts → llm-extraction.ts)
 // ============================================================================
 
-describe('extractFromTranscript', () => {
+describe('extractFromTranscript (wrapper)', () => {
   beforeEach(() => {
     vi.clearAllMocks();
+    // Prevent real network calls during these tests by unsetting the API key.
+    delete process.env.ANTHROPIC_API_KEY;
   });
 
-  it('extracts action-word lines from transcript', async () => {
+  it('returns without calling stores when transcript is empty', async () => {
     const { extractFromTranscript } = await import('../auto-extract.js');
     const { storeLearning } = await import('../learnings.js');
 
-    const transcript = [
-      'user: Can you implement the auth module?',
-      'assistant: I will implement the auth module now.',
-      'assistant: I have fixed the login bug in auth.ts.',
-      'assistant: This is a short line.',
-      'user: Great, what about the tests?',
-      'assistant: I will add tests for the auth module.',
-    ].join('\n');
-
-    await extractFromTranscript('/mock/root', 'S-001', transcript);
-
-    expect(storeLearning).toHaveBeenCalled();
-    const calls = (storeLearning as ReturnType<typeof vi.fn>).mock.calls;
-    // All stored learnings should come from action-word lines
-    for (const [, learning] of calls) {
-      expect(learning.source).toBe('transcript:S-001');
-      expect(learning.confidence).toBe(0.6);
-    }
-  });
-
-  it('limits to 5 learnings max', async () => {
-    const { extractFromTranscript } = await import('../auto-extract.js');
-    const { storeLearning } = await import('../learnings.js');
-
-    // Build a transcript with 10 action lines (all > 20 chars)
-    const lines = Array.from(
-      { length: 10 },
-      (_, i) => `assistant: I implemented feature number ${i + 1} successfully.`,
-    );
-    const transcript = lines.join('\n');
+    await extractFromTranscript('/mock/root', 'S-001', '');
+    await extractFromTranscript('/mock/root', 'S-001', '   \n  ');
 
-    await extractFromTranscript('/mock/root', 'S-002', transcript);
-
-    const calls = (storeLearning as ReturnType<typeof vi.fn>).mock.calls;
-    expect(calls.length).toBeLessThanOrEqual(5);
+    expect(storeLearning).not.toHaveBeenCalled();
   });
 
   it('never throws on malformed input', async () => {
@@ -531,13 +502,19 @@ describe('extractFromTranscript', () => {
     expect(result).toBeUndefined();
   });
 
-  it('does nothing when no action lines present', async () => {
+  it('skips storage when ANTHROPIC_API_KEY is absent', async () => {
     const { extractFromTranscript } = await import('../auto-extract.js');
     const { storeLearning } = await import('../learnings.js');
 
-    const transcript = ['user: Hello', 'assistant: Hi there', 'user: How are you?'].join('\n');
+    // No API key set — the LLM gate must gracefully skip.
+    const transcript = [
+      'user: Can you implement the auth module?',
+      'assistant: I will implement the auth module now.',
+      'assistant: I have fixed the login bug in auth.ts.',
+    ].join('\n');
 
     await extractFromTranscript('/mock/root', 'S-005', transcript);
+
     expect(storeLearning).not.toHaveBeenCalled();
   });
 });