@laitszkin/apollo-toolkit 4.0.11 → 4.1.1

package/packages/tools/codegraph/dist/lib/cmd-status.test.js

@@ -0,0 +1,72 @@
+import { describe, it, mock } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+describe('REGTEST-6: handleStatus — Languages section', () => {
+    it('should display filesByLanguage entries in human-readable output', async () => {
+        const testStats = {
+            fileCount: 100,
+            nodeCount: 500,
+            edgeCount: 200,
+            dbSizeBytes: 1_024_000,
+            lastUpdated: new Date('2026-06-01T12:00:00Z').toISOString(),
+            nodesByKind: { function: 50, class: 10 },
+            edgesByKind: { calls: 30, extends: 5 },
+            filesByLanguage: { typescript: 10, javascript: 5 },
+        };
+        const mockCg = {
+            getStats: () => testStats,
+            close: () => { },
+        };
+        // Load the same CodeGraph module that cmd-status.js uses (shared CJS cache),
+        // then mock CodeGraph.open + isInitialized so handleStatus uses our fake instance.
+        const { CodeGraph } = require('@colbymchenry/codegraph');
+        const openMock = mock.method(CodeGraph, 'open', async () => mockCg);
+        const initMock = mock.method(CodeGraph, 'isInitialized', () => true);
+        // Import the module under test AFTER the mock is in place
+        const { handleStatus } = await import('./cmd-status.js');
+        // Capture stdout writes
+        const chunks = [];
+        const originalWrite = process.stdout.write.bind(process.stdout);
+        process.stdout.write = (chunk) => {
+            chunks.push(String(chunk));
+            return true;
+        };
+        try {
+            const exitCode = await handleStatus('/test/project', {});
+            assert.strictEqual(exitCode, 0);
+            const output = chunks.join('');
+            assert.ok(output.includes('Languages:'), 'Output should contain "Languages:" section header');
+            assert.ok(output.includes('typescript'), 'Output should contain "typescript" language name');
+            assert.ok(output.includes('javascript'), 'Output should contain "javascript" language name');
+        }
+        finally {
+            process.stdout.write = originalWrite;
+            openMock.mock.restore();
+            initMock.mock.restore();
+        }
+    });
+    it('REGTEST-R2-02: should return exit code 1 when CodeGraph is not initialized', async () => {
+        const { CodeGraph } = require('@colbymchenry/codegraph');
+        const initMock = mock.method(CodeGraph, 'isInitialized', () => false);
+        // Import fresh (module cache returns same CodeGraph reference with mocked isInitialized)
+        const { handleStatus } = await import('./cmd-status.js');
+        // Capture stderr writes
+        const stderrChunks = [];
+        const originalStderrWrite = process.stderr.write.bind(process.stderr);
+        process.stderr.write = (chunk) => {
+            stderrChunks.push(String(chunk));
+            return true;
+        };
+        try {
+            const exitCode = await handleStatus('/test/project', {});
+            assert.strictEqual(exitCode, 1);
+            const stderrOutput = stderrChunks.join('');
+            assert.ok(stderrOutput.includes('CodeGraph is not initialized'), 'stderr should contain "CodeGraph is not initialized" message');
+        }
+        finally {
+            process.stderr.write = originalStderrWrite;
+            initMock.mock.restore();
+        }
+    });
+});

package/packages/tools/codegraph/dist/lib/cmd-survey.d.ts

@@ -0,0 +1,36 @@
+export interface SurveyOptions {
+    feature?: string;
+    json?: boolean;
+}
+export interface SurveyReport {
+    directory: string;
+    feature?: string;
+    totalFiles: number;
+    totalSymbols: number;
+    files: Array<{
+        filePath: string;
+        language: string;
+        symbolCount: number;
+    }>;
+    entryPoints: Array<{
+        name: string;
+        kind: string;
+        filePath: string;
+        startLine: number;
+        isExported: boolean;
+    }>;
+    suggestedSubmodules: Array<{
+        slug: string;
+        kind: string;
+        role: string;
+        memberFunctions: string[];
+        memberFiles: string[];
+    }>;
+    suggestedEdges: Array<{
+        source: string;
+        target: string;
+        kind: string;
+        label: string;
+    }>;
+}
+export declare function handleSurvey(projectRoot: string, dirPath: string, options?: SurveyOptions): Promise<number>;

package/packages/tools/codegraph/dist/lib/cmd-survey.js

@@ -0,0 +1,142 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { closeIndex } from './cg-instance.js';
+import { formatOutput } from './formatter.js';
+import { scanDirectory } from './survey/scanner.js';
+import { groupIntoSubmodules } from './survey/grouper.js';
+export async function handleSurvey(projectRoot, dirPath, options = {}) {
+    // Check that the target directory exists
+    const targetPath = path.resolve(projectRoot, dirPath);
+    if (!existsSync(targetPath)) {
+        process.stderr.write(`Error: Directory not found: ${dirPath}\n`);
+        return 1;
+    }
+    const { CodeGraph } = require('@colbymchenry/codegraph');
+    const cg = await CodeGraph.open(projectRoot, { sync: false, readOnly: true });
+    // Scan the directory
+    const scan = await scanDirectory(cg, dirPath);
+    const fileSet = new Set(scan.files.map((f) => f.filePath));
+    // Group into submodule suggestions
+    const suggestions = groupIntoSubmodules(scan, cg);
+    // Build edge suggestions from cross-file call relationships
+    const edgeSuggestions = buildEdgeSuggestions(scan, cg, fileSet);
+    // Determine entry points: exported symbols called from outside the scanned directory
+    const entryPoints = scan.allSymbols.filter(s => {
+        if (!s.isExported)
+            return false;
+        const nodes = cg.getNodesByName(s.name);
+        for (const node of nodes) {
+            if (node.filePath !== s.filePath)
+                continue;
+            const callers = cg.getCallers(node.id);
+            for (const caller of callers) {
+                if (!fileSet.has(caller.node.filePath)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    });
+    closeIndex(cg);
+    const report = {
+        directory: dirPath,
+        feature: options.feature,
+        totalFiles: scan.totalFiles,
+        totalSymbols: scan.totalSymbols,
+        files: scan.files.map((f) => ({
+            filePath: f.filePath,
+            language: f.language,
+            symbolCount: f.symbols.length,
+        })),
+        entryPoints,
+        suggestedSubmodules: suggestions.map((s) => ({
+            slug: s.slug,
+            kind: s.kind,
+            role: s.role,
+            memberFunctions: s.memberFunctions,
+            memberFiles: s.memberFiles,
+        })),
+        suggestedEdges: edgeSuggestions,
+    };
+    if (options.json) {
+        process.stdout.write(formatOutput(report, { json: true }) + '\n');
+    }
+    else {
+        // Human-readable output
+        process.stdout.write(`\n=== Survey: ${dirPath} ===\n`);
+        if (report.feature) {
+            process.stdout.write(`Feature: ${report.feature}\n`);
+        }
+        process.stdout.write('\n');
+        process.stdout.write(`Files: ${report.totalFiles}  Symbols: ${report.totalSymbols}\n\n`);
+        process.stdout.write('Files:\n');
+        for (const f of report.files) {
+            process.stdout.write(`  ${f.filePath}  [${f.language}]  (${f.symbolCount} symbols)\n`);
+        }
+        process.stdout.write('\nEntry Points:\n');
+        if (report.entryPoints.length === 0) {
+            process.stdout.write('  (none)\n');
+        }
+        else {
+            for (const ep of report.entryPoints) {
+                process.stdout.write(`  ${ep.name}  [${ep.kind}]  ${ep.filePath}:${ep.startLine}\n`);
+            }
+        }
+        process.stdout.write('\nSuggested Submodules:\n');
+        if (report.suggestedSubmodules.length === 0) {
+            process.stdout.write('  (none)\n');
+        }
+        else {
+            for (const sub of report.suggestedSubmodules) {
+                process.stdout.write(`  ${sub.slug}  [${sub.kind}]  ${sub.role}\n`);
+                process.stdout.write(`    Functions: ${sub.memberFunctions.join(', ')}\n`);
+                process.stdout.write(`    Files: ${sub.memberFiles.join(', ')}\n\n`);
+            }
+        }
+        process.stdout.write('Suggested Edges:\n');
+        if (report.suggestedEdges.length === 0) {
+            process.stdout.write('  (none)\n');
+        }
+        else {
+            for (const edge of report.suggestedEdges) {
+                process.stdout.write(`  ${edge.source} --[${edge.kind}]--> ${edge.target}  (${edge.label})\n`);
+            }
+        }
+        process.stdout.write('\n');
+    }
+    return 0;
+}
+/**
+ * Build suggested edges from cross-file call relationships in the scanned directory.
+ */
+function buildEdgeSuggestions(scan, cg, fileSet) {
+    const edges = [];
+    const dedup = new Set();
+    // For each symbol in the scan, check if it calls symbols outside the scanned directory
+    for (const sym of scan.allSymbols) {
+        const nodes = cg.getNodesByName(sym.name);
+        for (const node of nodes) {
+            if (node.filePath !== sym.filePath)
+                continue;
+            const callees = cg.getCallees(node.id);
+            for (const callee of callees) {
+                // Only consider callees OUTSIDE the scanned directory (cross-boundary edges)
+                if (!fileSet.has(callee.node.filePath)) {
+                    const edgeKey = `${sym.name}::${callee.node.name}`;
+                    if (dedup.has(edgeKey))
+                        continue;
+                    dedup.add(edgeKey);
+                    edges.push({
+                        source: sym.name,
+                        target: callee.node.name,
+                        kind: 'call',
+                        label: `${sym.filePath} -> ${callee.node.filePath}`,
+                    });
+                }
+            }
+        }
+    }
+    return edges;
+}

package/packages/tools/codegraph/dist/lib/cmd-survey.test.d.ts

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

package/packages/tools/codegraph/dist/lib/cmd-survey.test.js

@@ -0,0 +1,136 @@
+import { describe, it, before, beforeEach, afterEach, mock } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+describe('cmd-survey', () => {
+    let handleSurvey;
+    // Mock CodeGraph instance shared across tests:
+    // - Symbol A in src/feature/a.ts calls symbol B in src/lib/b.ts (cross-boundary)
+    // - Symbol X in src/feature/a.ts is exported but only called internally
+    const mockCg = {
+        getFiles: () => [{ path: 'src/feature/a.ts', language: 'typescript' }],
+        getNodesInFile: () => [
+            {
+                id: 'node-a',
+                name: 'A',
+                kind: 'function',
+                qualifiedName: 'A',
+                startLine: 1,
+                endLine: 10,
+                isExported: true,
+            },
+            {
+                id: 'node-x',
+                name: 'X',
+                kind: 'function',
+                qualifiedName: 'X',
+                startLine: 20,
+                endLine: 30,
+                isExported: true,
+            },
+        ],
+        getNodesByName: (name) => {
+            if (name === 'A') {
+                return [{ id: 'node-a', filePath: 'src/feature/a.ts', name: 'A' }];
+            }
+            if (name === 'X') {
+                return [{ id: 'node-x', filePath: 'src/feature/a.ts', name: 'X' }];
+            }
+            return [];
+        },
+        getCallees: (_id) => {
+            if (_id === 'node-a') {
+                return [{ node: { name: 'B', filePath: 'src/lib/b.ts' } }];
+            }
+            return [];
+        },
+        getCallers: (_id) => {
+            if (_id === 'node-x') {
+                return [{ node: { name: 'internal', filePath: 'src/feature/a.ts' } }];
+            }
+            return [];
+        },
+        close: () => { },
+    };
+    before(async () => {
+        // Module-level mocks (only need to be set up once):
+        mock.module('./survey/scanner.js', {
+            namedExports: {
+                scanDirectory: async () => ({
+                    directory: 'src/feature',
+                    files: [
+                        {
+                            filePath: 'src/feature/a.ts',
+                            language: 'typescript',
+                            symbols: [
+                                { name: 'A', kind: 'function', qualifiedName: 'A', startLine: 1, endLine: 10, isExported: true, signature: undefined },
+                                { name: 'X', kind: 'function', qualifiedName: 'X', startLine: 20, endLine: 30, isExported: true, signature: undefined },
+                            ],
+                        },
+                    ],
+                    allSymbols: [
+                        { name: 'A', kind: 'function', filePath: 'src/feature/a.ts', qualifiedName: 'A', startLine: 1, isExported: true },
+                        { name: 'X', kind: 'function', filePath: 'src/feature/a.ts', qualifiedName: 'X', startLine: 20, isExported: true },
+                    ],
+                    totalFiles: 1,
+                    totalSymbols: 2,
+                }),
+            },
+        });
+        mock.module('./survey/grouper.js', {
+            namedExports: { groupIntoSubmodules: () => [] },
+        });
+        mock.module('./cg-instance.js', {
+            namedExports: { closeIndex: () => { } },
+        });
+        // Import the compiled module (dist/lib/cmd-survey.js has the fixed code)
+        const mod = await import('./cmd-survey.js');
+        handleSurvey = mod.handleSurvey;
+    });
+    beforeEach(() => {
+        // Re-apply CodeGraph.open mock before each test (mock.reset() in afterEach clears it).
+        // Must use manual mock.method instead of mock.module because lazy CJS require()
+        // inside handlers bypasses mock.module interception.
+        const { CodeGraph } = require('@colbymchenry/codegraph');
+        mock.method(CodeGraph, 'open', async () => mockCg);
+    });
+    afterEach(() => {
+        mock.reset();
+    });
+    it('REGTEST-10: Cross-boundary edges point outside the scanned directory', async () => {
+        const stdoutChunks = [];
+        mock.method(process.stdout, 'write', (chunk) => {
+            stdoutChunks.push(String(chunk));
+            return true;
+        });
+        // Use a real directory for projectRoot so existsSync returns true naturally
+        const exitCode = await handleSurvey(process.cwd(), 'packages');
+        assert.equal(exitCode, 0);
+        const output = stdoutChunks.join('');
+        assert.ok(output.includes('src/feature/a.ts -> src/lib/b.ts'), `Expected cross-boundary edge label in output, got:\n${output}`);
+    });
+    it('REGTEST-11: Exported symbol called only from within the directory is not an entry point', async () => {
+        const stdoutChunks = [];
+        mock.method(process.stdout, 'write', (chunk) => {
+            stdoutChunks.push(String(chunk));
+            return true;
+        });
+        // Use a real directory for projectRoot so existsSync returns true naturally
+        const exitCode = await handleSurvey(process.cwd(), 'packages');
+        assert.equal(exitCode, 0);
+        const output = stdoutChunks.join('');
+        // X has only internal callers, so "(none)" should appear for entry points
+        assert.ok(output.includes('(none)'), `Expected "(none)" for entry points, got:\n${output}`);
+    });
+    it('REGTEST-12: Non-existent directory returns exit code 1 with error message', async () => {
+        const stderrChunks = [];
+        mock.method(process.stderr, 'write', (chunk) => {
+            stderrChunks.push(String(chunk));
+            return true;
+        });
+        // Use a path that does not exist on disk
+        const exitCode = await handleSurvey('/tmp', 'nonexistent-' + process.hrtime.bigint().toString());
+        assert.equal(exitCode, 1);
+        assert.ok(stderrChunks.join('').includes('Directory not found'), `Expected "Directory not found" error, got: ${stderrChunks.join('')}`);
+    });
+});

package/packages/tools/codegraph/dist/lib/cmd-sync.d.ts

@@ -0,0 +1,4 @@
+export interface SyncOptions {
+    json?: boolean;
+}
+export declare function handleSync(projectRoot: string, options?: SyncOptions): Promise<number>;

package/packages/tools/codegraph/dist/lib/cmd-sync.js

@@ -0,0 +1,51 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+import { closeIndex } from './cg-instance.js';
+import { formatSummary, formatOutput } from './formatter.js';
+export async function handleSync(projectRoot, options = {}) {
+    const { CodeGraph } = require('@colbymchenry/codegraph');
+    if (!CodeGraph.isInitialized(projectRoot)) {
+        process.stderr.write('CodeGraph is not initialized. Run `apltk codegraph init` first.\n');
+        return 1;
+    }
+    const cg = await CodeGraph.open(projectRoot, { sync: false, readOnly: false });
+    let progressEvents = [];
+    const result = await cg.sync({
+        onProgress: (p) => {
+            progressEvents.push({ phase: p.phase, current: p.current, total: p.total });
+            if (process.stdout.isTTY) {
+                process.stdout.write(`\r  Indexing: ${p.phase} ${p.current}/${p.total}`);
+            }
+        },
+    });
+    if (process.stdout.isTTY) {
+        process.stdout.write('\n');
+    }
+    closeIndex(cg);
+    const output = {
+        projectRoot,
+        filesChecked: result.filesChecked,
+        filesAdded: result.filesAdded,
+        filesModified: result.filesModified,
+        filesRemoved: result.filesRemoved,
+        nodesUpdated: result.nodesUpdated,
+        durationMs: result.durationMs,
+        progress: progressEvents.length > 0 ? progressEvents : undefined,
+    };
+    if (options.json) {
+        process.stdout.write(formatOutput(output, { json: true }) + '\n');
+    }
+    else {
+        const summary = [
+            ['Project:', projectRoot],
+            ['Checked:', result.filesChecked],
+            ['Added:', result.filesAdded],
+            ['Modified:', result.filesModified],
+            ['Removed:', result.filesRemoved],
+            ['Nodes updated:', result.nodesUpdated],
+            ['Duration:', `${result.durationMs}ms`],
+        ];
+        process.stdout.write(formatSummary(summary) + '\n');
+    }
+    return 0;
+}

package/packages/tools/codegraph/dist/lib/cmd-sync.test.d.ts

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

package/packages/tools/codegraph/dist/lib/cmd-sync.test.js

@@ -0,0 +1,30 @@
+import { describe, it, mock } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+describe('cmd-sync handleSync', () => {
+    it('should return exit code 1 when CodeGraph is not initialized', async () => {
+        // Pre-load CodeGraph via CJS require (same mechanism used by cmd-sync.ts)
+        // and mock isInitialized BEFORE the module under test is evaluated, so
+        // the mock is in place when cmd-sync.ts runs its own require().
+        const { CodeGraph } = require('@colbymchenry/codegraph');
+        const isInitializedMock = mock.method(CodeGraph, 'isInitialized', () => false);
+        // Capture stderr output
+        const stderrWriteMock = mock.method(process.stderr, 'write', () => true);
+        // Import the module under test after mocks are set up
+        const { handleSync } = await import('./cmd-sync.js');
+        // Call the handler with an uninitialized project
+        const exitCode = await handleSync('/tmp/fake-project', { json: false });
+        // Verify exit code is 1 (error)
+        assert.strictEqual(exitCode, 1);
+        // Verify stderr mentions "init"
+        assert.strictEqual(stderrWriteMock.mock.calls.length, 1);
+        const callArg = stderrWriteMock.mock.calls[0].arguments[0];
+        assert.ok(callArg !== undefined, 'Expected stderr write argument to be defined');
+        const stderrOutput = typeof callArg === 'string' ? callArg : Buffer.from(callArg).toString('utf8');
+        assert.ok(stderrOutput.toLowerCase().includes('init'), `Expected stderr to mention "init", got: ${JSON.stringify(stderrOutput)}`);
+        // Cleanup mocks
+        isInitializedMock.mock.restore();
+        stderrWriteMock.mock.restore();
+    });
+});

package/packages/tools/codegraph/dist/lib/cmd-verify.d.ts

@@ -0,0 +1,4 @@
+export interface VerifyOptions {
+    json?: boolean;
+}
+export declare function handleVerify(projectRoot: string, specDir: string, options?: VerifyOptions): Promise<number>;

package/packages/tools/codegraph/dist/lib/cmd-verify.js

@@ -0,0 +1,134 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+import { closeIndex } from './cg-instance.js';
+import { formatOutput } from './formatter.js';
+import { verifyOverlay } from './verify/checker.js';
+import yaml from 'js-yaml';
+/**
+ * Read a spec overlay from the standard atlas directory layout.
+ * Loads the overlay in the same way as skills/init-project-html/lib/atlas/state.js::loadOverlay.
+ */
+function loadOverlay(specDir) {
+    const overlayDir = path.join(specDir, 'architecture_diff', 'atlas');
+    if (!fs.existsSync(overlayDir)) {
+        throw new Error(`No architecture diff atlas found at: ${overlayDir}. Run "apltk architecture diff" first to generate the overlay.`);
+    }
+    const overlay = {
+        meta: null,
+        actors: null,
+        edges: null,
+        featureOrder: null,
+        features: {},
+        removed: { features: [], submodules: [] },
+    };
+    // Parse atlas.index.yaml via js-yaml
+    const indexFile = path.join(overlayDir, 'atlas.index.yaml');
+    if (fs.existsSync(indexFile)) {
+        const raw = fs.readFileSync(indexFile, 'utf8');
+        if (raw.trim()) {
+            const index = yaml.load(raw);
+            if (index && typeof index === 'object' && !Array.isArray(index)) {
+                if (index.meta !== undefined)
+                    overlay.meta = index.meta;
+                if (index.actors !== undefined)
+                    overlay.actors = index.actors;
+                if (index.edges !== undefined)
+                    overlay.edges = index.edges;
+                if (Array.isArray(index.features)) {
+                    overlay.featureOrder = index.features
+                        .map((entry) => (typeof entry === 'string' ? entry : entry?.slug))
+                        .filter(Boolean);
+                }
+            }
+        }
+    }
+    // Load feature files via js-yaml
+    const featuresDir = path.join(overlayDir, 'features');
+    if (fs.existsSync(featuresDir)) {
+        for (const entry of fs.readdirSync(featuresDir)) {
+            if (!entry.endsWith('.yaml'))
+                continue;
+            const featureFile = path.join(featuresDir, entry);
+            const raw = fs.readFileSync(featureFile, 'utf8');
+            if (raw.trim()) {
+                const data = yaml.load(raw);
+                if (data && typeof data === 'object' && data.slug) {
+                    const feature = {
+                        slug: data.slug,
+                        submodules: Array.isArray(data.submodules)
+                            ? data.submodules.map(normalizeSubmodule)
+                            : [],
+                        edges: Array.isArray(data.edges) ? data.edges : [],
+                    };
+                    if (data.action !== undefined)
+                        feature.action = data.action;
+                    overlay.features[data.slug] = feature;
+                }
+            }
+        }
+    }
+    // Load _removed.yaml via js-yaml
+    const removedFile = path.join(overlayDir, '_removed.yaml');
+    if (fs.existsSync(removedFile)) {
+        const raw = fs.readFileSync(removedFile, 'utf8');
+        if (raw.trim()) {
+            const removed = yaml.load(raw);
+            if (removed && typeof removed === 'object' && !Array.isArray(removed)) {
+                if (Array.isArray(removed.features))
+                    overlay.removed.features = removed.features;
+                if (Array.isArray(removed.submodules))
+                    overlay.removed.submodules = removed.submodules;
+            }
+        }
+    }
+    return overlay;
+}
+function normalizeSubmodule(sub) {
+    if (!sub || typeof sub !== 'object')
+        return sub;
+    return {
+        slug: sub.slug,
+        kind: sub.kind || 'service',
+        role: sub.role || '',
+        functions: Array.isArray(sub.functions) ? sub.functions : [],
+        variables: Array.isArray(sub.variables) ? sub.variables : [],
+        ...(sub.action !== undefined ? { action: sub.action } : {}),
+    };
+}
+export async function handleVerify(projectRoot, specDir, options = {}) {
+    const resolvedSpecDir = path.resolve(specDir);
+    let overlay;
+    try {
+        overlay = loadOverlay(resolvedSpecDir);
+    }
+    catch (err) {
+        process.stderr.write(`Error loading overlay: ${err.message}\n`);
+        return 1;
+    }
+    const { CodeGraph } = require('@colbymchenry/codegraph');
+    const cg = await CodeGraph.open(projectRoot, { sync: false, readOnly: true });
+    const report = await verifyOverlay(cg, overlay);
+    closeIndex(cg);
+    if (options.json) {
+        process.stdout.write(formatOutput(report, { json: true }) + '\n');
+    }
+    else {
+        process.stdout.write(`\n=== Verify Report ===\n\n`);
+        process.stdout.write(`Total:  ${report.total}\n`);
+        process.stdout.write(`Passed: ${report.passed}\n`);
+        process.stdout.write(`Failed: ${report.failed.length}\n`);
+        process.stdout.write(`Skipped: ${report.skipped}\n`);
+        if (report.failed.length > 0) {
+            process.stdout.write('\nFailures:\n');
+            for (const f of report.failed) {
+                process.stdout.write(`  [${f.type}] ${f.location}\n`);
+                if (f.suggestion)
+                    process.stdout.write(`    Suggestion: ${f.suggestion}\n`);
+            }
+        }
+        process.stdout.write('\n');
+    }
+    return report.failed.length > 0 ? 1 : 0;
+}

package/packages/tools/codegraph/dist/lib/cmd-verify.test.d.ts

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