@monoes/monograph 1.0.0

package/.monomind/data/ranked-context.json

@@ -0,0 +1,5 @@
+{
+  "version": 1,
+  "computedAt": 1777578175217,
+  "entries": []
+}

package/.monomind/sessions/current.json

@@ -0,0 +1,13 @@
+{
+  "id": "session-1777578175215",
+  "startedAt": "2026-04-30T19:42:55.215Z",
+  "platform": "darwin",
+  "cwd": "/Users/morteza/Desktop/tools/monobrain/packages/@monomind/monograph",
+  "context": {},
+  "metrics": {
+    "edits": 9,
+    "commands": 0,
+    "tasks": 0,
+    "errors": 0
+  }
+}

package/__tests__/export/formats.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { toJson } from '../../src/export/json.js';
+import { toCypher } from '../../src/export/cypher.js';
+import type { MonographNode, MonographEdge } from '../../src/types.js';
+
+let nodes: MonographNode[];
+let edges: MonographEdge[];
+
+beforeEach(() => {
+  nodes = [
+    { id: 'n1', label: 'Class', name: 'Foo', normLabel: 'foo', isExported: true },
+    { id: 'n2', label: 'Method', name: 'bar', normLabel: 'bar', isExported: false, filePath: 'foo.ts' },
+  ];
+  edges = [
+    { id: 'e1', sourceId: 'n1', targetId: 'n2', relation: 'CONTAINS', confidence: 'EXTRACTED', confidenceScore: 1.0 },
+    { id: 'e2', sourceId: 'n2', targetId: 'n1', relation: 'CALLS', confidence: 'INFERRED', confidenceScore: 0.5 },
+  ];
+});
+
+describe('json export', () => {
+  it('produces nodes and edges fields', () => {
+    const result = toJson(nodes, edges);
+    const parsed = JSON.parse(result);
+    expect(parsed.nodes).toHaveLength(2);
+    expect(parsed.edges).toHaveLength(2);
+  });
+
+  it('transforms node properties correctly', () => {
+    const result = toJson(nodes, edges);
+    const parsed = JSON.parse(result);
+    const firstNode = parsed.nodes[0];
+    expect(firstNode.id).toBe('n1');
+    expect(firstNode.label).toBe('Class');
+    expect(firstNode.norm_label).toBe('foo');
+    expect(firstNode.is_exported).toBe(true);
+  });
+
+  it('includes links array', () => {
+    const result = toJson(nodes, edges);
+    const parsed = JSON.parse(result);
+    expect(parsed.links).toBeDefined();
+    expect(parsed.links).toHaveLength(2);
+  });
+});
+
+describe('cypher export', () => {
+  it('does not include destructive operations', () => {
+    const result = toCypher(nodes, edges);
+    expect(result).toContain('CREATE');
+    // Verify no standalone destructive operations (DROP/DELETE statements, not in comments)
+    const lines = result.split('\n').filter(l => !l.trim().startsWith('//'));
+    expect(lines.some(l => l.includes('DROP'))).toBe(false);
+    expect(lines.some(l => l.includes('DELETE'))).toBe(false);
+  });
+
+  it('includes comment header', () => {
+    const result = toCypher(nodes, edges);
+    expect(result).toContain('// Generated by Monograph');
+  });
+
+  it('creates nodes and edges separately', () => {
+    const result = toCypher(nodes, edges);
+    const lines = result.split('\n');
+    const createNodeLines = lines.filter(l => l.includes('CREATE') && l.includes(':'));
+    expect(createNodeLines.length).toBeGreaterThan(0);
+  });
+
+  it('handles special characters safely', () => {
+    const nodeWithSpecial = {
+      ...nodes[0],
+      name: 'Foo"Bar"Baz',
+      id: 'n-special_id',
+    };
+    const result = toCypher([nodeWithSpecial], []);
+    // Verify escaped quotes in output
+    expect(result).toContain('\\"');
+    // Verify it doesn't have unescaped double quotes in the middle
+    const lines = result.split('\n');
+    const createLines = lines.filter(l => l.includes('CREATE') && l.includes('name:'));
+    expect(createLines.length).toBeGreaterThan(0);
+  });
+});

package/__tests__/fixtures/sample.py

@@ -0,0 +1,11 @@
+from os import path
+
+class UserService:
+    def __init__(self, db):
+        self.db = db
+
+    def get_user(self, user_id: str):
+        return self.db.find(user_id)
+
+def helper_fn(x: int) -> int:
+    return x * 2

package/__tests__/fixtures/sample.ts

@@ -0,0 +1,17 @@
+import { readFile } from 'fs/promises';
+
+export interface UserService {
+  getUser(id: string): Promise<User>;
+}
+
+export class UserServiceImpl implements UserService {
+  constructor(private db: Database) {}
+
+  async getUser(id: string): Promise<User> {
+    return this.db.find(id);
+  }
+}
+
+function helperFn(x: number): number {
+  return x * 2;
+}

package/__tests__/integration/full-pipeline.test.ts

@@ -0,0 +1,64 @@
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
+import { buildAsync } from '../../src/pipeline/orchestrator.js';
+import { openDb, closeDb } from '../../src/storage/db.js';
+import { countNodes } from '../../src/storage/node-store.js';
+import { countEdges } from '../../src/storage/edge-store.js';
+import { ftsSearch } from '../../src/storage/fts-store.js';
+
+const tmpRepo = join(tmpdir(), `monograph-integration-${Date.now()}`);
+
+beforeAll(() => {
+  mkdirSync(join(tmpRepo, 'src'), { recursive: true });
+  writeFileSync(join(tmpRepo, 'src', 'auth.ts'), `
+export interface AuthService {
+  login(username: string, password: string): Promise<boolean>;
+}
+export class AuthServiceImpl implements AuthService {
+  async login(username: string, password: string): Promise<boolean> {
+    return username.length > 0;
+  }
+}
+  `);
+  writeFileSync(join(tmpRepo, 'src', 'user.ts'), `
+import { AuthService } from './auth';
+export class UserController {
+  constructor(private auth: AuthService) {}
+  async authenticate(u: string, p: string) {
+    return this.auth.login(u, p);
+  }
+}
+  `);
+});
+
+afterAll(() => rmSync(tmpRepo, { recursive: true, force: true }));
+
+describe('full pipeline integration', () => {
+  it('builds without errors', async () => {
+    await expect(buildAsync(tmpRepo)).resolves.not.toThrow();
+  }, 30000);
+
+  it('creates the SQLite database', () => {
+    const dbPath = join(tmpRepo, '.monomind', 'monograph.db');
+    expect(existsSync(dbPath)).toBe(true);
+  });
+
+  it('indexes nodes and edges', () => {
+    const dbPath = join(tmpRepo, '.monomind', 'monograph.db');
+    const db = openDb(dbPath);
+    const nodes = countNodes(db);
+    const edges = countEdges(db);
+    closeDb(db);
+    expect(nodes).toBeGreaterThan(2);
+    expect(edges).toBeGreaterThan(0);
+  });
+
+  it('FTS search finds AuthService', () => {
+    const dbPath = join(tmpRepo, '.monomind', 'monograph.db');
+    const db = openDb(dbPath);
+    const results = ftsSearch(db, 'AuthService', 10);
+    closeDb(db);
+    expect(results.some(r => r.name === 'AuthService' || r.name === 'AuthServiceImpl')).toBe(true);
+  });
+}, 60000);

package/__tests__/parsers/loader.test.ts

@@ -0,0 +1,14 @@
+import { getParser, isSupportedExtension } from '../../src/parsers/loader.js';
+
+describe('isSupportedExtension', () => {
+  it('recognises .ts', () => expect(isSupportedExtension('.ts')).toBe(true));
+  it('recognises .py', () => expect(isSupportedExtension('.py')).toBe(true));
+  it('rejects .css', () => expect(isSupportedExtension('.css')).toBe(false));
+});
+
+describe('getParser', () => {
+  it('returns a parser for TypeScript', async () => {
+    const parser = await getParser('.ts');
+    expect(parser).toBeDefined();
+  });
+});

package/__tests__/parsers/python.test.ts

@@ -0,0 +1,32 @@
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { parseFile } from '../../src/parsers/loader.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const fixturePath = join(__dirname, '../fixtures/sample.py');
+
+describe('Python parser', () => {
+  let result: Awaited<ReturnType<typeof parseFile>>;
+
+  beforeAll(async () => {
+    const source = readFileSync(fixturePath, 'utf-8');
+    result = await parseFile(fixturePath, source, 'src/sample.py');
+  });
+
+  it('extracts the class', () => {
+    expect(result.nodes.some(n => n.label === 'Class' && n.name === 'UserService')).toBe(true);
+  });
+
+  it('extracts the method', () => {
+    expect(result.nodes.some(n => n.label === 'Method' && n.name === 'get_user')).toBe(true);
+  });
+
+  it('extracts the function', () => {
+    expect(result.nodes.some(n => n.label === 'Function' && n.name === 'helper_fn')).toBe(true);
+  });
+
+  it('extracts IMPORTS edge for os.path', () => {
+    expect(result.edges.some(e => e.relation === 'IMPORTS')).toBe(true);
+  });
+});

package/__tests__/parsers/typescript.test.ts

@@ -0,0 +1,45 @@
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { parseFile } from '../../src/parsers/loader.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const fixturePath = join(__dirname, '../fixtures/sample.ts');
+
+describe('TypeScript parser', () => {
+  let result: Awaited<ReturnType<typeof parseFile>>;
+
+  beforeAll(async () => {
+    const source = readFileSync(fixturePath, 'utf-8');
+    result = await parseFile(fixturePath, source, 'src/sample.ts');
+  });
+
+  it('extracts the interface node', () => {
+    expect(result.nodes.some(n => n.label === 'Interface' && n.name === 'UserService')).toBe(true);
+  });
+
+  it('extracts the class node', () => {
+    expect(result.nodes.some(n => n.label === 'Class' && n.name === 'UserServiceImpl')).toBe(true);
+  });
+
+  it('extracts the function node', () => {
+    expect(result.nodes.some(n => n.label === 'Function' && n.name === 'helperFn')).toBe(true);
+  });
+
+  it('extracts the method node', () => {
+    expect(result.nodes.some(n => n.label === 'Method' && n.name === 'getUser')).toBe(true);
+  });
+
+  it('extracts the IMPLEMENTS edge', () => {
+    expect(result.edges.some(e => e.relation === 'IMPLEMENTS')).toBe(true);
+  });
+
+  it('extracts the IMPORTS edge for fs/promises', () => {
+    expect(result.edges.some(e => e.relation === 'IMPORTS' && e.targetId.includes('fs'))).toBe(true);
+  });
+
+  it('marks exported symbols', () => {
+    const cls = result.nodes.find(n => n.name === 'UserServiceImpl');
+    expect(cls?.isExported).toBe(true);
+  });
+});

package/__tests__/pipeline/analysis.test.ts

@@ -0,0 +1,58 @@
+import { vi } from 'vitest';
+import type { PipelineContext } from '../../src/pipeline/types.js';
+import { godNodesPhase } from '../../src/pipeline/phases/god-nodes.js';
+import { suggestPhase } from '../../src/pipeline/phases/suggest.js';
+
+describe('god-nodes phase', () => {
+  it('returns top nodes by degree, excluding File/Folder nodes', async () => {
+    const ctx = { onProgress: vi.fn() } as unknown as PipelineContext;
+    const deps = new Map<string, unknown>();
+    deps.set('cross-file', {
+      resolvedEdges: [
+        { id: 'e1', sourceId: 'cls_a', targetId: 'fn_b', relation: 'CALLS', confidence: 'EXTRACTED', confidenceScore: 1.0 },
+        { id: 'e2', sourceId: 'cls_a', targetId: 'fn_c', relation: 'CALLS', confidence: 'EXTRACTED', confidenceScore: 1.0 },
+      ]
+    });
+    deps.set('parse', {
+      symbolNodes: [
+        { id: 'cls_a', label: 'Class', name: 'A', normLabel: 'a', isExported: true },
+        { id: 'fn_b', label: 'Function', name: 'b', normLabel: 'b', isExported: false },
+        { id: 'fn_c', label: 'Function', name: 'c', normLabel: 'c', isExported: false },
+        { id: 'file_x', label: 'File', name: 'x.ts', normLabel: 'x.ts', isExported: false },
+      ],
+      allEdges: []
+    });
+
+    const result = await godNodesPhase.execute(ctx, deps) as { godNodes: unknown[] };
+    const ids = result.godNodes.map((n: any) => n.id);
+    expect(ids).toContain('cls_a');
+    expect(ids).not.toContain('file_x');
+  });
+});
+
+describe('suggest phase', () => {
+  it('returns at least one signal type', async () => {
+    const ctx = { onProgress: vi.fn() } as unknown as PipelineContext;
+    const deps = new Map<string, unknown>();
+
+    deps.set('parse', {
+      symbolNodes: [
+        { id: 'n1', label: 'Class', name: 'A', normLabel: 'a', isExported: false },
+        { id: 'n2', label: 'Class', name: 'B', normLabel: 'b', isExported: false },
+      ],
+      allEdges: [{
+        id: 'e1', sourceId: 'n1', targetId: 'n2',
+        relation: 'CALLS', confidence: 'AMBIGUOUS', confidenceScore: 0.2
+      }]
+    });
+    deps.set('cross-file', { resolvedEdges: [] });
+    deps.set('mro', { mroEdges: [] });
+    deps.set('communities', { memberships: new Map(), communityLabels: new Map() });
+    deps.set('god-nodes', { godNodes: [] });
+    deps.set('surprises', { surprises: [] });
+
+    const result = await suggestPhase.execute(ctx, deps) as { questions: unknown[] };
+    expect(result.questions.length).toBeGreaterThan(0);
+    expect((result.questions[0] as any).type).toBe('ambiguous_edge');
+  });
+});

package/__tests__/pipeline/phases.test.ts

@@ -0,0 +1,41 @@
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { mkdirSync, writeFileSync, rmSync } from 'fs';
+import { scanPhase } from '../../src/pipeline/phases/scan.js';
+import { structurePhase } from '../../src/pipeline/phases/structure.js';
+import type { PipelineContext } from '../../src/pipeline/types.js';
+
+const tmpRepo = join(tmpdir(), `monograph-test-repo-${Date.now()}`);
+
+beforeAll(() => {
+  mkdirSync(join(tmpRepo, 'src'), { recursive: true });
+  writeFileSync(join(tmpRepo, 'src', 'index.ts'), 'export const x = 1;');
+  writeFileSync(join(tmpRepo, 'src', 'util.py'), 'def helper(): pass');
+});
+
+afterAll(() => rmSync(tmpRepo, { recursive: true, force: true }));
+
+const ctx = {
+  repoPath: tmpRepo,
+  onProgress: vi.fn(),
+  options: { codeOnly: false, ignore: [], maxFileSizeBytes: 524288, workerPoolThreshold: 15, workerChunkBudgetBytes: 20971520 },
+} as unknown as PipelineContext;
+
+describe('scan phase', () => {
+  it('finds source files', async () => {
+    const outputs = new Map<string, unknown>();
+    const result = await scanPhase.execute(ctx, outputs) as { filePaths: string[] };
+    expect(result.filePaths.length).toBeGreaterThan(0);
+    expect(result.filePaths.some(p => p.endsWith('index.ts'))).toBe(true);
+  });
+});
+
+describe('structure phase', () => {
+  it('creates File and Folder nodes', async () => {
+    const outputs = new Map<string, unknown>();
+    const scanOutput = await scanPhase.execute(ctx, outputs);
+    outputs.set('scan', scanOutput);
+    const result = await structurePhase.execute(ctx, outputs) as { fileNodes: unknown[] };
+    expect(result.fileNodes.length).toBeGreaterThan(0);
+  });
+});

package/__tests__/pipeline/runner.test.ts

@@ -0,0 +1,28 @@
+import { PipelineRunner } from '../../src/pipeline/runner.js';
+import type { PipelinePhase, PipelineContext } from '../../src/pipeline/types.js';
+
+describe('PipelineRunner', () => {
+  it('executes phases in dependency order', async () => {
+    const order: string[] = [];
+
+    const phases: PipelinePhase<unknown>[] = [
+      { name: 'c', deps: ['a', 'b'], execute: async () => { order.push('c'); return 'c'; } },
+      { name: 'a', deps: [],         execute: async () => { order.push('a'); return 'a'; } },
+      { name: 'b', deps: ['a'],      execute: async () => { order.push('b'); return 'b'; } },
+    ];
+
+    const runner = new PipelineRunner(phases);
+    await runner.run({} as PipelineContext);
+
+    expect(order.indexOf('a')).toBeLessThan(order.indexOf('b'));
+    expect(order.indexOf('b')).toBeLessThan(order.indexOf('c'));
+  });
+
+  it('throws on cycle detection', () => {
+    const phases: PipelinePhase<unknown>[] = [
+      { name: 'a', deps: ['b'], execute: async () => null },
+      { name: 'b', deps: ['a'], execute: async () => null },
+    ];
+    expect(() => new PipelineRunner(phases)).toThrow(/cycle/i);
+  });
+});

package/__tests__/setup.ts

@@ -0,0 +1 @@
+// Vitest setup file - placeholder for future test configuration

package/__tests__/storage/db.test.ts

@@ -0,0 +1,37 @@
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { unlinkSync, existsSync } from 'fs';
+import { openDb, closeDb } from '../../src/storage/db.js';
+
+describe('openDb', () => {
+  const dbPath = join(tmpdir(), `monograph-test-${Date.now()}.db`);
+
+  afterEach(() => { if (existsSync(dbPath)) unlinkSync(dbPath); });
+
+  it('creates a new database file', () => {
+    const db = openDb(dbPath);
+    closeDb(db);
+    expect(existsSync(dbPath)).toBe(true);
+  });
+
+  it('creates the nodes table', () => {
+    const db = openDb(dbPath);
+    const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='nodes'").get();
+    closeDb(db);
+    expect(row).toBeDefined();
+  });
+
+  it('creates the edges table', () => {
+    const db = openDb(dbPath);
+    const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='edges'").get();
+    closeDb(db);
+    expect(row).toBeDefined();
+  });
+
+  it('creates the nodes_fts virtual table', () => {
+    const db = openDb(dbPath);
+    const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='nodes_fts'").get();
+    closeDb(db);
+    expect(row).toBeDefined();
+  });
+});

package/__tests__/storage/stores.test.ts

@@ -0,0 +1,100 @@
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { unlinkSync, existsSync } from 'fs';
+import { openDb, closeDb } from '../../src/storage/db.js';
+import { insertNode, getNode, deleteNodesForFile } from '../../src/storage/node-store.js';
+import { insertEdge, getEdgesForSource } from '../../src/storage/edge-store.js';
+import { ftsSearch } from '../../src/storage/fts-store.js';
+import type { MonographNode, MonographEdge } from '../../src/types.js';
+
+const dbPath = join(tmpdir(), `monograph-stores-${Date.now()}.db`);
+let db: ReturnType<typeof openDb>;
+
+beforeAll(() => {
+  db = openDb(dbPath);
+});
+
+afterAll(() => {
+  closeDb(db);
+  if (existsSync(dbPath)) {
+    unlinkSync(dbPath);
+  }
+  // Also cleanup WAL files
+  if (existsSync(dbPath + '-wal')) unlinkSync(dbPath + '-wal');
+  if (existsSync(dbPath + '-shm')) unlinkSync(dbPath + '-shm');
+});
+
+describe('node-store', () => {
+  const node: MonographNode = {
+    id: 'foo_bar',
+    label: 'Function',
+    name: 'bar',
+    normLabel: 'bar',
+    filePath: 'src/foo.ts',
+    startLine: 10,
+    endLine: 20,
+    isExported: true,
+    language: 'typescript',
+  };
+
+  it('inserts and retrieves a node', () => {
+    insertNode(db, node);
+    const fetched = getNode(db, 'foo_bar');
+    expect(fetched?.name).toBe('bar');
+    expect(fetched?.isExported).toBe(true);
+  });
+
+  it('deletes nodes by file path', () => {
+    deleteNodesForFile(db, 'src/foo.ts');
+    expect(getNode(db, 'foo_bar')).toBeUndefined();
+  });
+});
+
+describe('edge-store', () => {
+  beforeAll(() => {
+    insertNode(db, {
+      id: 'n1',
+      label: 'Class',
+      name: 'A',
+      normLabel: 'a',
+      isExported: false,
+    });
+    insertNode(db, {
+      id: 'n2',
+      label: 'Class',
+      name: 'B',
+      normLabel: 'b',
+      isExported: false,
+    });
+  });
+
+  it('inserts and retrieves edges by source', () => {
+    const edge: MonographEdge = {
+      id: 'e1',
+      sourceId: 'n1',
+      targetId: 'n2',
+      relation: 'EXTENDS',
+      confidence: 'EXTRACTED',
+      confidenceScore: 1.0,
+    };
+    insertEdge(db, edge);
+    const edges = getEdgesForSource(db, 'n1');
+    expect(edges).toHaveLength(1);
+    expect(edges[0].relation).toBe('EXTENDS');
+  });
+});
+
+describe('fts-store', () => {
+  it('finds nodes by keyword', () => {
+    insertNode(db, {
+      id: 'auth_service',
+      label: 'Class',
+      name: 'AuthService',
+      normLabel: 'authservice',
+      filePath: 'src/auth.ts',
+      isExported: true,
+    });
+    const results = ftsSearch(db, 'auth', 10);
+    expect(results.some((r) => r.id === 'auth_service')).toBe(true);
+  });
+});

package/__tests__/types.test.ts

@@ -0,0 +1,13 @@
+import { CONFIDENCE_SCORE } from '../src/types.js';
+
+describe('CONFIDENCE_SCORE', () => {
+  it('assigns 1.0 to EXTRACTED', () => {
+    expect(CONFIDENCE_SCORE.EXTRACTED).toBe(1.0);
+  });
+  it('assigns 0.5 to INFERRED', () => {
+    expect(CONFIDENCE_SCORE.INFERRED).toBe(0.5);
+  });
+  it('assigns 0.2 to AMBIGUOUS', () => {
+    expect(CONFIDENCE_SCORE.AMBIGUOUS).toBe(0.2);
+  });
+});

package/__tests__/watch/watcher.test.ts

@@ -0,0 +1,31 @@
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { mkdirSync, writeFileSync, rmSync, appendFileSync } from 'fs';
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { MonographWatcher } from '../../src/watch/watcher.js';
+
+const tmpRepo = join(tmpdir(), `monograph-watch-test-${Date.now()}`);
+
+beforeAll(() => {
+  mkdirSync(join(tmpRepo, 'src'), { recursive: true });
+  writeFileSync(join(tmpRepo, 'src', 'index.ts'), 'export const x = 1;');
+});
+
+afterAll(() => rmSync(tmpRepo, { recursive: true, force: true }));
+
+describe('MonographWatcher', () => {
+  it('emits monograph:updated within 5s after a file change', async () => {
+    const updates: string[] = [];
+    const watcher = new MonographWatcher(tmpRepo, { debounceMs: 200 });
+    watcher.on('monograph:updated', (paths: string[]) => updates.push(...paths));
+    await watcher.start();
+
+    // Trigger a file change
+    await new Promise(r => setTimeout(r, 300));
+    appendFileSync(join(tmpRepo, 'src', 'index.ts'), '\nexport const y = 2;');
+    await new Promise(r => setTimeout(r, 2000));
+
+    await watcher.stop();
+    expect(updates.length).toBeGreaterThan(0);
+  }, 15000);
+});

package/dist/src/export/canvas.d.ts

@@ -0,0 +1,3 @@
+import type { MonographNode, MonographEdge } from '../types.js';
+export declare function toCanvas(nodes: MonographNode[], edges: MonographEdge[]): string;
+//# sourceMappingURL=canvas.d.ts.map

package/dist/src/export/canvas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas.d.ts","sourceRoot":"","sources":["../../../src/export/canvas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEhE,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,MAAM,CAqB/E"}

package/dist/src/export/canvas.js

@@ -0,0 +1,39 @@
+export function toCanvas(nodes, edges) {
+    const canvasNodes = nodes.map((n, i) => ({
+        id: n.id,
+        type: 'text',
+        text: `**${n.label}**\n${n.name}`,
+        x: (i % 20) * 200,
+        y: Math.floor(i / 20) * 120,
+        width: 180,
+        height: 80,
+        color: labelColor(n.label),
+    }));
+    const canvasEdges = edges.map(e => ({
+        id: e.id,
+        fromNode: e.sourceId,
+        toNode: e.targetId,
+        label: e.relation,
+        color: confidenceColor(e.confidence),
+    }));
+    return JSON.stringify({ nodes: canvasNodes, edges: canvasEdges }, null, 2);
+}
+function labelColor(label) {
+    const map = {
+        Class: '1',
+        Function: '2',
+        Interface: '3',
+        Module: '4',
+        Namespace: '5',
+        Method: '6',
+    };
+    return map[label] ?? '6';
+}
+function confidenceColor(c) {
+    if (c === 'EXTRACTED')
+        return '#22c55e';
+    if (c === 'INFERRED')
+        return '#f59e0b';
+    return '#ef4444';
+}
+//# sourceMappingURL=canvas.js.map

package/dist/src/export/canvas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas.js","sourceRoot":"","sources":["../../../src/export/canvas.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,QAAQ,CAAC,KAAsB,EAAE,KAAsB;IACrE,MAAM,WAAW,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;QACvC,EAAE,EAAE,CAAC,CAAC,EAAE;QACR,IAAI,EAAE,MAAM;QACZ,IAAI,EAAE,KAAK,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,IAAI,EAAE;QACjC,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,GAAG;QACjB,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,GAAG;QAC3B,KAAK,EAAE,GAAG;QACV,MAAM,EAAE,EAAE;QACV,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC;KAC3B,CAAC,CAAC,CAAC;IAEJ,MAAM,WAAW,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAClC,EAAE,EAAE,CAAC,CAAC,EAAE;QACR,QAAQ,EAAE,CAAC,CAAC,QAAQ;QACpB,MAAM,EAAE,CAAC,CAAC,QAAQ;QAClB,KAAK,EAAE,CAAC,CAAC,QAAQ;QACjB,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,UAAU,CAAC;KACrC,CAAC,CAAC,CAAC;IAEJ,OAAO,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;AAC7E,CAAC;AAED,SAAS,UAAU,CAAC,KAAa;IAC/B,MAAM,GAAG,GAA2B;QAClC,KAAK,EAAE,GAAG;QACV,QAAQ,EAAE,GAAG;QACb,SAAS,EAAE,GAAG;QACd,MAAM,EAAE,GAAG;QACX,SAAS,EAAE,GAAG;QACd,MAAM,EAAE,GAAG;KACZ,CAAC;IACF,OAAO,GAAG,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC;AAC3B,CAAC;AAED,SAAS,eAAe,CAAC,CAAS;IAChC,IAAI,CAAC,KAAK,WAAW;QAAE,OAAO,SAAS,CAAC;IACxC,IAAI,CAAC,KAAK,UAAU;QAAE,OAAO,SAAS,CAAC;IACvC,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/src/export/cypher.d.ts

@@ -0,0 +1,3 @@
+import type { MonographNode, MonographEdge } from '../types.js';
+export declare function toCypher(nodes: MonographNode[], edges: MonographEdge[]): string;
+//# sourceMappingURL=cypher.d.ts.map