@claudetools/tools 0.8.5 → 0.8.7

package/dist/cli.js

@@ -12,6 +12,7 @@ import { startServer } from './index.js';
 import { startWatcher, stopWatcher, watcherStatus } from './watcher.js';
 import { generateCodebaseMap, generateCodebaseMapLocal } from './helpers/codebase-mapper.js';
 import { contextStatus, contextEvict, contextSummarise, contextReset, } from './context-cli.js';
+import { runTests } from './test-runner.js';
 // Get version from package.json
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -61,6 +62,9 @@ Commands:
   context evict    Manually trigger eviction cycle
   context summarise Summarise and compress exchanges
   context reset    Clear session state
+  test             Run integration test suite
+  test --verbose   Run tests with detailed output
+  test --json      Output results in JSON format
 
 Running without options starts the MCP server.
 
@@ -206,6 +210,16 @@ else if (positionals[0] === 'context') {
             process.exit(1);
     }
 }
+else if (positionals[0] === 'test') {
+    // Handle test command
+    const testArgs = process.argv.slice(3); // Get args after 'test'
+    const verbose = testArgs.includes('--verbose');
+    const json = testArgs.includes('--json');
+    runTests({ verbose, json }).catch((error) => {
+        console.error('Test run failed:', error);
+        process.exit(1);
+    });
+}
 else {
     // Start MCP server
     startServer();

package/dist/handlers/tool-handlers.js

@@ -133,9 +133,8 @@ export function registerToolHandlers(server) {
                     const entity2 = args?.entity2;
                     const context = args?.context;
                     const is_critical = args?.is_critical;
-                    // Commercial-grade storage with blocking verification
+                    // Storage with read-after-write verification (DO-level)
                     const MAX_RETRIES = 3;
-                    const VERIFY_DELAY_MS = 200;
                     let lastError = null;
                     let storedFactId = null;
                     let storedIsCritical = false;
@@ -144,32 +143,24 @@ export function registerToolHandlers(server) {
                     for (let attempt = 1; attempt <= MAX_RETRIES && !verified; attempt++) {
                         attempts = attempt;
                         try {
-                            // Step 1: Store the fact
                             mcpLogger.info('STORE', `Attempt ${attempt}/${MAX_RETRIES}: Storing "${entity1} ${relationship} ${entity2}"${is_critical ? ' [CRITICAL]' : ''}`);
                             const result = await storeFact(projectId, entity1, relationship, entity2, context, { is_critical });
                             storedFactId = result.fact_id;
                             storedIsCritical = result.is_critical;
                             mcpLogger.info('STORE', `Storage response: ${JSON.stringify(result)}`);
                             if (!result.success || !result.fact_id) {
-                                lastError = new Error(`Storage returned unsuccessful: ${JSON.stringify(result)}`);
+                                lastError = new Error(`Storage returned unsuccessful: ${result.error || 'Unknown error'}`);
                                 mcpLogger.warn('STORE', `Attempt ${attempt} failed: ${lastError.message}`);
                                 continue;
                             }
-                            // Step 2: Wait briefly for eventual consistency
-                            await new Promise(resolve => setTimeout(resolve, VERIFY_DELAY_MS));
-                            // Step 3: Verify the fact is retrievable by searching for it
-                            mcpLogger.info('STORE', `Verifying fact ${storedFactId} is retrievable...`);
-                            const searchQuery = `${entity1} ${relationship} ${entity2}`;
-                            const searchResult = await searchMemory(projectId, searchQuery, 5);
-                            // Check if our fact appears in results
-                            const factFound = searchResult.relevant_facts?.some(f => f.fact?.includes(entity1) && f.fact?.includes(entity2)) || false;
-                            if (factFound) {
+                            // Check DO-level verification (read-after-write in Durable Object)
+                            if (result.verified) {
                                 verified = true;
-                                mcpLogger.info('STORE', `✓ Fact verified as retrievable`);
+                                mcpLogger.info('STORE', `✓ Fact verified at storage layer (ID: ${storedFactId})`);
                             }
                             else {
-                                lastError = new Error(`Fact stored but not found in search results`);
-                                mcpLogger.warn('STORE', `Attempt ${attempt}: Stored but not retrievable. Search returned ${searchResult.relevant_facts?.length || 0} facts.`);
+                                lastError = new Error(`Storage verification failed at DO level`);
+                                mcpLogger.warn('STORE', `Attempt ${attempt}: Storage layer verification failed`);
                             }
                         }
                         catch (err) {

package/dist/helpers/api-client.d.ts

@@ -33,6 +33,8 @@ export declare function storeFact(projectId: string, entity1: string, relationsh
     success: boolean;
     fact_id: string;
     is_critical: boolean;
+    verified?: boolean;
+    error?: string;
 }>;
 export declare function getContext(projectId: string, query?: string, userId?: string): Promise<MemoryContext>;
 export declare function getSummary(projectId: string, userId?: string): Promise<string>;

package/dist/helpers/api-client.js

@@ -64,7 +64,18 @@ export async function injectContext(projectId, query, userId = DEFAULT_USER_ID)
     const response = await apiRequest(`/api/v1/memory/${userId}/${projectId}/inject`, 'POST', {
         query,
     });
-    return response.data;
+    // Transform API response to match expected interface
+    // Handle cases where context or metadata might be missing
+    return {
+        augmentedSystemPrompt: response.data.context || '',
+        metadata: response.data.metadata || {
+            memoryNeeded: false,
+            retrievalTimeMs: 0,
+            factsScored: 0,
+            factsIncluded: 0,
+            avgRelevanceScore: 0,
+        },
+    };
 }
 /**
  * List all cached documentation libraries (global cache)

package/dist/index.d.ts

@@ -2,6 +2,8 @@ export type { ExpertWorker } from './helpers/workers.js';
 export type { Task, TaskContext, DispatchableTask } from './helpers/tasks.js';
 export type { DeduplicationTracker } from './context/index.js';
 export type { CircuitState } from './helpers/circuit-breaker.js';
+export type { TestResult, TestSuite, TestSuiteSummary, TestFunction, TestDefinition, } from './testing/index.js';
+export { runTest, runSuite, formatResults, formatResultsJson, assert, assertEqual, assertThrows, } from './testing/index.js';
 export { EXPERT_WORKERS, matchTaskToWorker } from './helpers/workers.js';
 export { parseJsonArray, getDispatchableTasks, getExecutionContext, resolveTaskDependencies, createTask, listTasks, getTask, claimTask, releaseTask, updateTaskStatus, addTaskContext, getTaskSummary, heartbeatTask } from './helpers/tasks.js';
 export { injectContext } from './helpers/api-client.js';

package/dist/index.js

@@ -11,6 +11,7 @@ import { registerToolHandlers } from './handlers/tool-handlers.js';
 // Resource and prompt handlers
 import { registerResourceHandlers } from './resources.js';
 import { registerPromptHandlers } from './prompts.js';
+export { runTest, runSuite, formatResults, formatResultsJson, assert, assertEqual, assertThrows, } from './testing/index.js';
 // Re-export functions that are used by handlers
 export { EXPERT_WORKERS, matchTaskToWorker } from './helpers/workers.js';
 export { parseJsonArray, getDispatchableTasks, getExecutionContext, resolveTaskDependencies, createTask, listTasks, getTask, claimTask, releaseTask, updateTaskStatus, addTaskContext, getTaskSummary, heartbeatTask } from './helpers/tasks.js';

package/dist/test-runner.d.ts

@@ -0,0 +1,33 @@
+export interface TestResult {
+    name: string;
+    status: 'pass' | 'fail' | 'error';
+    duration: number;
+    error?: string;
+    details?: any;
+}
+export interface TestSuiteResult {
+    totalTests: number;
+    passed: number;
+    failed: number;
+    errors: number;
+    duration: number;
+    tests: TestResult[];
+}
+export interface TestOptions {
+    verbose?: boolean;
+    json?: boolean;
+}
+/**
+ * Run all integration tests in the suite.
+ *
+ * This is the main entry point that imports and runs all test files:
+ * - Store-Retrieve-Verify test
+ * - Context Injection test
+ * - Task Lifecycle test
+ * - Cross-Project Isolation test
+ */
+export declare function runSuite(): Promise<TestSuiteResult>;
+/**
+ * Run tests from CLI with options.
+ */
+export declare function runTests(options?: TestOptions): Promise<void>;

package/dist/test-runner.js

@@ -0,0 +1,149 @@
+// =============================================================================
+// Integration Test Runner
+// =============================================================================
+// Runs the full integration test suite and outputs results
+// Supports --verbose and --json output formats
+// -----------------------------------------------------------------------------
+// Test Suite Runner
+// -----------------------------------------------------------------------------
+/**
+ * Run all integration tests in the suite.
+ *
+ * This is the main entry point that imports and runs all test files:
+ * - Store-Retrieve-Verify test
+ * - Context Injection test
+ * - Task Lifecycle test
+ * - Cross-Project Isolation test
+ */
+export async function runSuite() {
+    const startTime = Date.now();
+    const results = [];
+    // TODO: Import and run actual test files once they're implemented
+    // Example structure:
+    //
+    // import { runStoreRetrieveTest } from './__tests__/store-retrieve-verify.js';
+    // import { runContextInjectionTest } from './__tests__/context-injection.js';
+    // import { runTaskLifecycleTest } from './__tests__/task-lifecycle.js';
+    // import { runCrossProjectTest } from './__tests__/cross-project-isolation.js';
+    //
+    // const tests = [
+    //   { name: 'Store-Retrieve-Verify', fn: runStoreRetrieveTest },
+    //   { name: 'Context Injection', fn: runContextInjectionTest },
+    //   { name: 'Task Lifecycle', fn: runTaskLifecycleTest },
+    //   { name: 'Cross-Project Isolation', fn: runCrossProjectTest },
+    // ];
+    //
+    // for (const test of tests) {
+    //   const result = await runTest(test.name, test.fn);
+    //   results.push(result);
+    // }
+    // Placeholder: Add a simple test to demonstrate structure
+    results.push({
+        name: 'Placeholder Test',
+        status: 'pass',
+        duration: 0,
+        details: { message: 'Test harness ready - add actual tests' }
+    });
+    const duration = Date.now() - startTime;
+    const passed = results.filter(r => r.status === 'pass').length;
+    const failed = results.filter(r => r.status === 'fail').length;
+    const errors = results.filter(r => r.status === 'error').length;
+    return {
+        totalTests: results.length,
+        passed,
+        failed,
+        errors,
+        duration,
+        tests: results,
+    };
+}
+/**
+ * Run a single test and capture result.
+ */
+async function runTest(name, testFn) {
+    const startTime = Date.now();
+    try {
+        await testFn();
+        return {
+            name,
+            status: 'pass',
+            duration: Date.now() - startTime,
+        };
+    }
+    catch (error) {
+        const isAssertionError = error instanceof Error && error.message.includes('AssertionError');
+        return {
+            name,
+            status: isAssertionError ? 'fail' : 'error',
+            duration: Date.now() - startTime,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+// -----------------------------------------------------------------------------
+// Output Formatting
+// -----------------------------------------------------------------------------
+/**
+ * Format results as human-readable text.
+ */
+function formatHumanReadable(result, verbose) {
+    const lines = [];
+    lines.push('');
+    lines.push('Integration Test Suite Results');
+    lines.push('================================');
+    lines.push('');
+    lines.push(`Total Tests: ${result.totalTests}`);
+    lines.push(`Passed:      ${result.passed}`);
+    lines.push(`Failed:      ${result.failed}`);
+    lines.push(`Errors:      ${result.errors}`);
+    lines.push(`Duration:    ${result.duration}ms`);
+    lines.push('');
+    if (verbose || result.failed > 0 || result.errors > 0) {
+        lines.push('Test Details:');
+        lines.push('');
+        for (const test of result.tests) {
+            const statusIcon = test.status === 'pass' ? '✓' : '✗';
+            lines.push(`${statusIcon} ${test.name} (${test.duration}ms)`);
+            if (test.error) {
+                lines.push(`  Error: ${test.error}`);
+            }
+            if (verbose && test.details) {
+                lines.push(`  Details: ${JSON.stringify(test.details, null, 2)}`);
+            }
+            lines.push('');
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Format results as JSON.
+ */
+function formatJSON(result) {
+    return JSON.stringify(result, null, 2);
+}
+// -----------------------------------------------------------------------------
+// CLI Entry Point
+// -----------------------------------------------------------------------------
+/**
+ * Run tests from CLI with options.
+ */
+export async function runTests(options = {}) {
+    const { verbose = false, json = false } = options;
+    try {
+        console.error('Running integration tests...\n');
+        const result = await runSuite();
+        if (json) {
+            console.log(formatJSON(result));
+        }
+        else {
+            console.log(formatHumanReadable(result, verbose));
+        }
+        // Exit with code 0 if all pass, 1 if any fail
+        const exitCode = result.failed + result.errors > 0 ? 1 : 0;
+        process.exit(exitCode);
+    }
+    catch (error) {
+        console.error('Fatal error running test suite:', error);
+        process.exit(1);
+    }
+}

package/dist/testing/example.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/testing/example.js

@@ -0,0 +1,63 @@
+// =============================================================================
+// Test Runner Example Usage
+// =============================================================================
+//
+// This file demonstrates how to use the test harness for integration testing.
+// Run with: tsx src/testing/example.ts
+//
+import { runSuite, formatResults, formatResultsJson, assert, assertEqual, assertThrows, } from './test-runner.js';
+// Example: Memory integration tests
+async function exampleUsage() {
+    const suite = await runSuite('Memory Integration Example', [
+        {
+            name: 'should pass basic assertion',
+            fn: async () => {
+                const value = 42;
+                assert(value === 42, 'Value should be 42');
+            },
+        },
+        {
+            name: 'should pass equality check',
+            fn: async () => {
+                const obj = { id: '123', name: 'Test' };
+                assertEqual(obj, { id: '123', name: 'Test' });
+            },
+        },
+        {
+            name: 'should catch expected errors',
+            fn: async () => {
+                await assertThrows(async () => {
+                    throw new Error('Invalid input');
+                }, 'Invalid input');
+            },
+        },
+        {
+            name: 'should fail on purpose',
+            fn: async () => {
+                // This test intentionally fails to demonstrate error handling
+                assert(false, 'This is a deliberate failure');
+            },
+        },
+        {
+            name: 'should handle async operations',
+            fn: async () => {
+                // Simulate async API call
+                await new Promise(resolve => setTimeout(resolve, 50));
+                const result = { success: true };
+                assert(result.success === true);
+            },
+        },
+    ]);
+    // Print human-readable results
+    console.log(formatResults(suite));
+    // Example: Save JSON results to file
+    console.log('\n--- JSON Output ---\n');
+    console.log(formatResultsJson(suite));
+    // Exit with appropriate code
+    process.exit(suite.summary.failed > 0 ? 1 : 0);
+}
+// Run example
+exampleUsage().catch(error => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/testing/index.d.ts

@@ -0,0 +1 @@
+export { TestResult, TestSuite, TestSuiteSummary, TestFunction, TestDefinition, runTest, runSuite, formatResults, formatResultsJson, assert, assertEqual, assertThrows, } from './test-runner.js';

package/dist/testing/index.js

@@ -0,0 +1,13 @@
+// =============================================================================
+// Agent-Based Integration Testing
+// =============================================================================
+//
+// Re-exports for test runner and utilities
+//
+export { 
+// Core test runner functions
+runTest, runSuite, 
+// Formatting
+formatResults, formatResultsJson, 
+// Assertion helpers
+assert, assertEqual, assertThrows, } from './test-runner.js';

package/dist/testing/test-runner.d.ts

@@ -0,0 +1,220 @@
+/**
+ * Result of a single test execution
+ */
+export interface TestResult {
+    /** Test name/description */
+    name: string;
+    /** Whether the test passed */
+    passed: boolean;
+    /** Duration in milliseconds */
+    duration_ms: number;
+    /** Error details if test failed */
+    error?: {
+        message: string;
+        stack?: string;
+    };
+}
+/**
+ * Summary of test suite execution
+ */
+export interface TestSuiteSummary {
+    /** Total number of tests */
+    total: number;
+    /** Number of passed tests */
+    passed: number;
+    /** Number of failed tests */
+    failed: number;
+    /** Total duration in milliseconds */
+    total_duration_ms: number;
+    /** Average duration per test in milliseconds */
+    avg_duration_ms: number;
+    /** Pass rate as percentage (0-100) */
+    pass_rate: number;
+}
+/**
+ * Complete test suite results
+ */
+export interface TestSuite {
+    /** Suite name */
+    name: string;
+    /** Individual test results */
+    tests: TestResult[];
+    /** Aggregated summary */
+    summary: TestSuiteSummary;
+    /** Timestamp when suite started */
+    started_at: string;
+    /** Timestamp when suite completed */
+    completed_at: string;
+}
+/**
+ * Test function signature
+ */
+export type TestFunction = () => Promise<void> | void;
+/**
+ * Test definition
+ */
+export interface TestDefinition {
+    name: string;
+    fn: TestFunction;
+}
+/**
+ * Run a single test with timing and error handling
+ *
+ * @param name - Test name/description
+ * @param fn - Test function to execute
+ * @returns Test result with pass/fail, duration, and error details
+ *
+ * @example
+ * ```typescript
+ * const result = await runTest('should store and retrieve fact', async () => {
+ *   const fact = await storeFact('test', 'RELATES_TO', 'value');
+ *   assert(fact !== null);
+ * });
+ *
+ * if (!result.passed) {
+ *   console.error(`Test failed: ${result.error?.message}`);
+ * }
+ * ```
+ */
+export declare function runTest(name: string, fn: TestFunction): Promise<TestResult>;
+/**
+ * Run a suite of tests
+ *
+ * @param name - Suite name
+ * @param tests - Array of test definitions
+ * @returns Complete test suite results with summary
+ *
+ * @example
+ * ```typescript
+ * const suite = await runSuite('Memory Integration Tests', [
+ *   { name: 'should store fact', fn: async () => { ... } },
+ *   { name: 'should search facts', fn: async () => { ... } },
+ *   { name: 'should inject context', fn: async () => { ... } },
+ * ]);
+ *
+ * console.log(formatResults(suite));
+ *
+ * if (suite.summary.failed > 0) {
+ *   process.exit(1);
+ * }
+ * ```
+ */
+export declare function runSuite(name: string, tests: TestDefinition[]): Promise<TestSuite>;
+/**
+ * Format test suite results as human-readable text
+ *
+ * @param suite - Test suite results
+ * @returns Formatted string with test results and summary
+ *
+ * @example
+ * ```typescript
+ * const suite = await runSuite('My Tests', [...]);
+ * console.log(formatResults(suite));
+ * ```
+ *
+ * Output:
+ * ```
+ * ================================================================================
+ * Test Suite: My Tests
+ * ================================================================================
+ *
+ * ✓ should pass test 1 (45.32ms)
+ * ✗ should fail test 2 (12.18ms)
+ *   Error: Expected value to be true
+ *
+ * --------------------------------------------------------------------------------
+ * Summary
+ * --------------------------------------------------------------------------------
+ * Total:     2
+ * Passed:    1
+ * Failed:    1
+ * Pass Rate: 50.00%
+ * Duration:  57.50ms (avg: 28.75ms)
+ * ```
+ */
+export declare function formatResults(suite: TestSuite): string;
+/**
+ * Format test suite results as JSON
+ *
+ * @param suite - Test suite results
+ * @param pretty - Whether to pretty-print the JSON (default: true)
+ * @returns JSON string
+ *
+ * @example
+ * ```typescript
+ * const suite = await runSuite('My Tests', [...]);
+ * const json = formatResultsJson(suite);
+ * await fs.writeFile('test-results.json', json);
+ * ```
+ *
+ * Output:
+ * ```json
+ * {
+ *   "name": "My Tests",
+ *   "started_at": "2025-01-01T12:00:00.000Z",
+ *   "completed_at": "2025-01-01T12:00:01.234Z",
+ *   "summary": {
+ *     "total": 5,
+ *     "passed": 4,
+ *     "failed": 1,
+ *     "pass_rate": 80.00,
+ *     "total_duration_ms": 1234.56,
+ *     "avg_duration_ms": 246.91
+ *   },
+ *   "tests": [...]
+ * }
+ * ```
+ */
+export declare function formatResultsJson(suite: TestSuite, pretty?: boolean): string;
+/**
+ * Create a simple assertion helper for tests
+ *
+ * @param condition - Condition to check
+ * @param message - Error message if assertion fails
+ * @throws Error if condition is false
+ *
+ * @example
+ * ```typescript
+ * await runTest('should work', async () => {
+ *   const result = await someOperation();
+ *   assert(result !== null, 'Result should not be null');
+ *   assert(result.value === 'expected', 'Value should be expected');
+ * });
+ * ```
+ */
+export declare function assert(condition: boolean, message?: string): asserts condition;
+/**
+ * Deep equality assertion
+ *
+ * @param actual - Actual value
+ * @param expected - Expected value
+ * @param message - Error message if assertion fails
+ * @throws Error if values are not equal
+ *
+ * @example
+ * ```typescript
+ * await runTest('should match object', async () => {
+ *   const result = await getUser();
+ *   assertEqual(result, { id: '123', name: 'Test' });
+ * });
+ * ```
+ */
+export declare function assertEqual<T>(actual: T, expected: T, message?: string): void;
+/**
+ * Async error assertion helper
+ *
+ * @param fn - Function that should throw
+ * @param expectedMessage - Optional expected error message
+ * @throws Error if function doesn't throw
+ *
+ * @example
+ * ```typescript
+ * await runTest('should reject invalid input', async () => {
+ *   await assertThrows(
+ *     async () => await validateInput('invalid'),
+ *     'Invalid input format'
+ *   );
+ * });
+ * ```
+ */
+export declare function assertThrows(fn: () => Promise<void> | void, expectedMessage?: string): Promise<void>;

package/dist/testing/test-runner.js

@@ -0,0 +1,302 @@
+// =============================================================================
+// Agent-Based Integration Test Runner
+// =============================================================================
+//
+// Core test harness for running integration tests against the ClaudeTools
+// memory system. Provides result collection, timing, and reporting.
+//
+/**
+ * Run a single test with timing and error handling
+ *
+ * @param name - Test name/description
+ * @param fn - Test function to execute
+ * @returns Test result with pass/fail, duration, and error details
+ *
+ * @example
+ * ```typescript
+ * const result = await runTest('should store and retrieve fact', async () => {
+ *   const fact = await storeFact('test', 'RELATES_TO', 'value');
+ *   assert(fact !== null);
+ * });
+ *
+ * if (!result.passed) {
+ *   console.error(`Test failed: ${result.error?.message}`);
+ * }
+ * ```
+ */
+export async function runTest(name, fn) {
+    const startTime = performance.now();
+    try {
+        await fn();
+        const duration_ms = performance.now() - startTime;
+        return {
+            name,
+            passed: true,
+            duration_ms: Math.round(duration_ms * 100) / 100, // Round to 2 decimal places
+        };
+    }
+    catch (error) {
+        const duration_ms = performance.now() - startTime;
+        const err = error;
+        return {
+            name,
+            passed: false,
+            duration_ms: Math.round(duration_ms * 100) / 100,
+            error: {
+                message: err.message || String(error),
+                stack: err.stack,
+            },
+        };
+    }
+}
+/**
+ * Calculate summary statistics from test results
+ *
+ * @param tests - Array of test results
+ * @returns Aggregated summary with counts, duration, and pass rate
+ */
+function calculateSummary(tests) {
+    const total = tests.length;
+    const passed = tests.filter(t => t.passed).length;
+    const failed = total - passed;
+    const total_duration_ms = tests.reduce((sum, t) => sum + t.duration_ms, 0);
+    const avg_duration_ms = total > 0
+        ? Math.round((total_duration_ms / total) * 100) / 100
+        : 0;
+    const pass_rate = total > 0
+        ? Math.round((passed / total) * 10000) / 100 // Round to 2 decimal places
+        : 0;
+    return {
+        total,
+        passed,
+        failed,
+        total_duration_ms: Math.round(total_duration_ms * 100) / 100,
+        avg_duration_ms,
+        pass_rate,
+    };
+}
+/**
+ * Run a suite of tests
+ *
+ * @param name - Suite name
+ * @param tests - Array of test definitions
+ * @returns Complete test suite results with summary
+ *
+ * @example
+ * ```typescript
+ * const suite = await runSuite('Memory Integration Tests', [
+ *   { name: 'should store fact', fn: async () => { ... } },
+ *   { name: 'should search facts', fn: async () => { ... } },
+ *   { name: 'should inject context', fn: async () => { ... } },
+ * ]);
+ *
+ * console.log(formatResults(suite));
+ *
+ * if (suite.summary.failed > 0) {
+ *   process.exit(1);
+ * }
+ * ```
+ */
+export async function runSuite(name, tests) {
+    const started_at = new Date().toISOString();
+    // Run all tests sequentially
+    const results = [];
+    for (const test of tests) {
+        const result = await runTest(test.name, test.fn);
+        results.push(result);
+    }
+    const completed_at = new Date().toISOString();
+    const summary = calculateSummary(results);
+    return {
+        name,
+        tests: results,
+        summary,
+        started_at,
+        completed_at,
+    };
+}
+/**
+ * Format test suite results as human-readable text
+ *
+ * @param suite - Test suite results
+ * @returns Formatted string with test results and summary
+ *
+ * @example
+ * ```typescript
+ * const suite = await runSuite('My Tests', [...]);
+ * console.log(formatResults(suite));
+ * ```
+ *
+ * Output:
+ * ```
+ * ================================================================================
+ * Test Suite: My Tests
+ * ================================================================================
+ *
+ * ✓ should pass test 1 (45.32ms)
+ * ✗ should fail test 2 (12.18ms)
+ *   Error: Expected value to be true
+ *
+ * --------------------------------------------------------------------------------
+ * Summary
+ * --------------------------------------------------------------------------------
+ * Total:     2
+ * Passed:    1
+ * Failed:    1
+ * Pass Rate: 50.00%
+ * Duration:  57.50ms (avg: 28.75ms)
+ * ```
+ */
+export function formatResults(suite) {
+    const lines = [];
+    // Header
+    lines.push('='.repeat(80));
+    lines.push(`Test Suite: ${suite.name}`);
+    lines.push('='.repeat(80));
+    lines.push('');
+    // Individual test results
+    for (const test of suite.tests) {
+        const icon = test.passed ? '✓' : '✗';
+        const status = test.passed ? 'PASS' : 'FAIL';
+        lines.push(`${icon} ${test.name} (${test.duration_ms}ms)`);
+        if (!test.passed && test.error) {
+            lines.push(`  Error: ${test.error.message}`);
+            if (test.error.stack) {
+                const stackLines = test.error.stack.split('\n').slice(1, 4); // First 3 stack frames
+                stackLines.forEach(line => lines.push(`  ${line.trim()}`));
+            }
+        }
+    }
+    // Summary
+    lines.push('');
+    lines.push('-'.repeat(80));
+    lines.push('Summary');
+    lines.push('-'.repeat(80));
+    lines.push(`Total:     ${suite.summary.total}`);
+    lines.push(`Passed:    ${suite.summary.passed}`);
+    lines.push(`Failed:    ${suite.summary.failed}`);
+    lines.push(`Pass Rate: ${suite.summary.pass_rate}%`);
+    lines.push(`Duration:  ${suite.summary.total_duration_ms}ms (avg: ${suite.summary.avg_duration_ms}ms)`);
+    lines.push('');
+    // Overall result
+    const overallStatus = suite.summary.failed === 0 ? 'PASSED ✓' : 'FAILED ✗';
+    lines.push(`Overall: ${overallStatus}`);
+    lines.push('='.repeat(80));
+    return lines.join('\n');
+}
+/**
+ * Format test suite results as JSON
+ *
+ * @param suite - Test suite results
+ * @param pretty - Whether to pretty-print the JSON (default: true)
+ * @returns JSON string
+ *
+ * @example
+ * ```typescript
+ * const suite = await runSuite('My Tests', [...]);
+ * const json = formatResultsJson(suite);
+ * await fs.writeFile('test-results.json', json);
+ * ```
+ *
+ * Output:
+ * ```json
+ * {
+ *   "name": "My Tests",
+ *   "started_at": "2025-01-01T12:00:00.000Z",
+ *   "completed_at": "2025-01-01T12:00:01.234Z",
+ *   "summary": {
+ *     "total": 5,
+ *     "passed": 4,
+ *     "failed": 1,
+ *     "pass_rate": 80.00,
+ *     "total_duration_ms": 1234.56,
+ *     "avg_duration_ms": 246.91
+ *   },
+ *   "tests": [...]
+ * }
+ * ```
+ */
+export function formatResultsJson(suite, pretty = true) {
+    return pretty
+        ? JSON.stringify(suite, null, 2)
+        : JSON.stringify(suite);
+}
+/**
+ * Create a simple assertion helper for tests
+ *
+ * @param condition - Condition to check
+ * @param message - Error message if assertion fails
+ * @throws Error if condition is false
+ *
+ * @example
+ * ```typescript
+ * await runTest('should work', async () => {
+ *   const result = await someOperation();
+ *   assert(result !== null, 'Result should not be null');
+ *   assert(result.value === 'expected', 'Value should be expected');
+ * });
+ * ```
+ */
+export function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message || 'Assertion failed');
+    }
+}
+/**
+ * Deep equality assertion
+ *
+ * @param actual - Actual value
+ * @param expected - Expected value
+ * @param message - Error message if assertion fails
+ * @throws Error if values are not equal
+ *
+ * @example
+ * ```typescript
+ * await runTest('should match object', async () => {
+ *   const result = await getUser();
+ *   assertEqual(result, { id: '123', name: 'Test' });
+ * });
+ * ```
+ */
+export function assertEqual(actual, expected, message) {
+    const actualJson = JSON.stringify(actual);
+    const expectedJson = JSON.stringify(expected);
+    if (actualJson !== expectedJson) {
+        const msg = message || `Expected ${expectedJson} but got ${actualJson}`;
+        throw new Error(msg);
+    }
+}
+/**
+ * Async error assertion helper
+ *
+ * @param fn - Function that should throw
+ * @param expectedMessage - Optional expected error message
+ * @throws Error if function doesn't throw
+ *
+ * @example
+ * ```typescript
+ * await runTest('should reject invalid input', async () => {
+ *   await assertThrows(
+ *     async () => await validateInput('invalid'),
+ *     'Invalid input format'
+ *   );
+ * });
+ * ```
+ */
+export async function assertThrows(fn, expectedMessage) {
+    try {
+        await fn();
+        throw new Error('Expected function to throw an error');
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === 'Expected function to throw an error') {
+            throw error;
+        }
+        if (expectedMessage) {
+            const actualMessage = error instanceof Error ? error.message : String(error);
+            if (!actualMessage.includes(expectedMessage)) {
+                throw new Error(`Expected error message to include "${expectedMessage}" but got "${actualMessage}"`);
+            }
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claudetools/tools",
-  "version": "0.8.5",
+  "version": "0.8.7",
   "description": "Persistent AI memory, task management, and codebase intelligence for Claude Code",
   "type": "module",
   "main": "dist/index.js",
@@ -14,6 +14,22 @@
     "README.md",
     "LICENSE"
   ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "prepublishOnly": "npm run build",
+    "codedna:monitor": "tsx -e \"import { runMonitoring } from './src/helpers/codedna-monitoring.js'; runMonitoring()\"",
+    "codedna:analytics": "tsx -e \"import { weeklyAnalyticsSummary } from './src/helpers/usage-analytics.js'; weeklyAnalyticsSummary()\"",
+    "codedna:analytics:24h": "tsx -e \"import { getLast24HoursAnalytics, printAnalytics } from './src/helpers/usage-analytics.js'; const r = await getLast24HoursAnalytics(); printAnalytics(r, 'Last 24 Hours')\"",
+    "codedna:analytics:30d": "tsx -e \"import { getLast30DaysAnalytics, printAnalytics } from './src/helpers/usage-analytics.js'; const r = await getLast30DaysAnalytics(); printAnalytics(r, 'Last 30 Days')\"",
+    "prompt:verify": "scripts/verify-prompt-compliance.sh",
+    "eval:build-dataset": "tsx src/evaluation/build-dataset.ts",
+    "eval:threshold": "tsx src/evaluation/threshold-eval.ts"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/claudetools/memory.git"
@@ -42,6 +58,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
+    "better-sqlite3": "^12.5.0",
     "chalk": "^5.6.2",
     "nunjucks": "^3.2.4",
     "ora": "^9.0.0",
@@ -54,24 +71,8 @@
     "@types/nunjucks": "^3.2.6",
     "@types/prompts": "^2.4.9",
     "@vitest/ui": "^4.0.15",
-    "better-sqlite3": "^12.5.0",
     "tsx": "^4.7.0",
     "typescript": "^5.3.0",
     "vitest": "^4.0.15"
-  },
-  "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "dev": "tsx src/index.ts",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:ui": "vitest --ui",
-    "codedna:monitor": "tsx -e \"import { runMonitoring } from './src/helpers/codedna-monitoring.js'; runMonitoring()\"",
-    "codedna:analytics": "tsx -e \"import { weeklyAnalyticsSummary } from './src/helpers/usage-analytics.js'; weeklyAnalyticsSummary()\"",
-    "codedna:analytics:24h": "tsx -e \"import { getLast24HoursAnalytics, printAnalytics } from './src/helpers/usage-analytics.js'; const r = await getLast24HoursAnalytics(); printAnalytics(r, 'Last 24 Hours')\"",
-    "codedna:analytics:30d": "tsx -e \"import { getLast30DaysAnalytics, printAnalytics } from './src/helpers/usage-analytics.js'; const r = await getLast30DaysAnalytics(); printAnalytics(r, 'Last 30 Days')\"",
-    "prompt:verify": "scripts/verify-prompt-compliance.sh",
-    "eval:build-dataset": "tsx src/evaluation/build-dataset.ts",
-    "eval:threshold": "tsx src/evaluation/threshold-eval.ts"
   }
-}
+}