@psnext/lscg 0.1.1

package/dist/src/graph/attribution.js

@@ -0,0 +1,112 @@
+import { spawnSync } from 'node:child_process';
+export function buildFileAttribution({ root, relativePath, source, nodes }) {
+    const blameLines = blameFile(root, relativePath);
+    if (!blameLines)
+        return null;
+    const lineStarts = buildLineStarts(source);
+    const contributorEmails = new Map();
+    const nodeAttributions = nodes.flatMap((node) => {
+        const span = lineSpanForNode(node, lineStarts);
+        const uniqueEmails = new Set();
+        let latest = null;
+        for (let lineNumber = span.startLine; lineNumber <= span.endLine; lineNumber += 1) {
+            const blame = blameLines[lineNumber];
+            if (!blame)
+                continue;
+            uniqueEmails.add(blame.email);
+            contributorEmails.set(blame.email, { email: blame.email });
+            if (!latest || blame.timestamp > latest.timestamp || (blame.timestamp === latest.timestamp && lineNumber > latest.lineNumber)) {
+                latest = { ...blame, lineNumber };
+            }
+        }
+        return [{
+                nodeId: node.id,
+                contributorEmails: [...uniqueEmails].sort(),
+                lastModifiedEmail: latest?.email ?? null
+            }];
+    });
+    return {
+        contributorEmails: [...contributorEmails.values()].sort((left, right) => left.email.localeCompare(right.email)),
+        nodeAttributions
+    };
+}
+function blameFile(root, relativePath) {
+    const result = spawnSync('git', ['-C', root, 'blame', '--follow', '--line-porcelain', '--', relativePath], {
+        encoding: 'utf8'
+    });
+    if (result.error || result.status !== 0 || !result.stdout.trim()) {
+        return null;
+    }
+    const lines = result.stdout.split(/\r?\n/);
+    const blameLines = [];
+    let currentEmail = null;
+    let currentTimestamp = 0;
+    for (const line of lines) {
+        if (!line)
+            continue;
+        if (isHeaderLine(line)) {
+            currentEmail = null;
+            currentTimestamp = 0;
+            continue;
+        }
+        if (line.startsWith('author-mail ')) {
+            currentEmail = normalizeEmail(line.slice('author-mail '.length));
+            continue;
+        }
+        if (line.startsWith('author-time ')) {
+            currentTimestamp = Number(line.slice('author-time '.length)) || 0;
+            continue;
+        }
+        if (line.startsWith('\t')) {
+            if (currentEmail) {
+                blameLines.push({ email: currentEmail, timestamp: currentTimestamp });
+            }
+        }
+    }
+    return blameLines.length > 0 ? blameLines : null;
+}
+function isHeaderLine(line) {
+    return /^[0-9a-f]{7,40} \d+ \d+(?: \d+)?$/.test(line);
+}
+function normalizeEmail(value) {
+    return value.trim().replace(/^<|>$/g, '').toLowerCase();
+}
+function buildLineStarts(source) {
+    const buffer = Buffer.from(source, 'utf8');
+    const starts = [0];
+    for (let index = 0; index < buffer.length; index += 1) {
+        if (buffer[index] === 0x0a && index + 1 < buffer.length) {
+            starts.push(index + 1);
+        }
+    }
+    return starts;
+}
+function lineSpanForNode(node, lineStarts) {
+    if (lineStarts.length === 0) {
+        return { startLine: 0, endLine: 0 };
+    }
+    const startLine = lineIndexForByte(lineStarts, node.startByte);
+    const endLine = lineIndexForByte(lineStarts, Math.max(node.startByte, node.endByte - 1));
+    return {
+        startLine,
+        endLine: Math.max(startLine, endLine)
+    };
+}
+function lineIndexForByte(lineStarts, byteIndex) {
+    let low = 0;
+    let high = lineStarts.length - 1;
+    let result = 0;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const lineStart = lineStarts[mid] ?? 0;
+        if (lineStart <= byteIndex) {
+            result = mid;
+            low = mid + 1;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=attribution.js.map

package/dist/src/graph/extract.d.ts

@@ -0,0 +1,4 @@
+import type { ExtractGraphInput, GraphExtractionResult } from '../types.js';
+export declare function extractGraph({ repositoryId, fileId, relativePath, source, sourceHash, parseResult }: ExtractGraphInput): GraphExtractionResult;
+export declare function hashParts(parts: Array<string | number>): string;
+//# sourceMappingURL=extract.d.ts.map

package/dist/src/graph/extract.js

@@ -0,0 +1,199 @@
+import { createHash } from 'node:crypto';
+import Parser from 'tree-sitter';
+const INTERESTING_TYPES = new Set([
+    'class_declaration',
+    'function_declaration',
+    'method_definition',
+    'variable_declarator',
+    'import_statement',
+    'export_statement',
+    'call_expression'
+]);
+export function extractGraph({ repositoryId, fileId, relativePath, source, sourceHash, parseResult }) {
+    const sourceBuffer = Buffer.from(source, 'utf8');
+    const nodes = [];
+    const edges = [];
+    const fileNode = makeNode({
+        repositoryId,
+        fileId,
+        relativePath,
+        kind: 'file',
+        type: 'file',
+        name: relativePath,
+        startByte: 0,
+        endByte: sourceBuffer.length,
+        startPoint: { row: 0, column: 0 },
+        endPoint: parseResult.tree.rootNode.endPosition,
+        sourceHash,
+        parser: parseResult.parser,
+        parserVersion: parseResult.parserVersion,
+        metadata: { language: parseResult.language }
+    });
+    nodes.push(fileNode);
+    walk(parseResult.tree.rootNode, []);
+    return { nodes, edges };
+    function walk(treeNode, ancestry) {
+        let currentGraphNode = null;
+        let nextAncestry = ancestry;
+        if (INTERESTING_TYPES.has(treeNode.type)) {
+            currentGraphNode = treeNodeToGraphNode(treeNode);
+            nodes.push(currentGraphNode);
+            const parentGraphNode = ancestry.at(-1) ?? fileNode;
+            const edgeKind = edgeKindFor(parentGraphNode, currentGraphNode);
+            edges.push(makeEdge(repositoryId, fileId, parentGraphNode.id, currentGraphNode.id, edgeKind, {
+                discoveredFrom: treeNode.type
+            }));
+            if (currentGraphNode.kind === 'import') {
+                edges.push(makeEdge(repositoryId, fileId, fileNode.id, currentGraphNode.id, 'imports', {
+                    module: currentGraphNode.metadata.module ?? currentGraphNode.name
+                }));
+            }
+            if (currentGraphNode.kind === 'export') {
+                edges.push(makeEdge(repositoryId, fileId, fileNode.id, currentGraphNode.id, 'exports', {}));
+            }
+            if (currentGraphNode.kind === 'call') {
+                const caller = ancestry.findLast((node) => node.kind === 'symbol') ?? fileNode;
+                edges.push(makeEdge(repositoryId, fileId, caller.id, currentGraphNode.id, 'calls', {
+                    callee: currentGraphNode.name
+                }));
+            }
+            nextAncestry = [...ancestry, currentGraphNode];
+        }
+        for (const child of treeNode.namedChildren) {
+            walk(child, nextAncestry);
+        }
+    }
+    function treeNodeToGraphNode(treeNode) {
+        const kind = kindForTreeNode(treeNode);
+        const name = nameForTreeNode(treeNode, sourceBuffer);
+        return makeNode({
+            repositoryId,
+            fileId,
+            relativePath,
+            kind,
+            type: treeNode.type,
+            name,
+            startByte: treeNode.startIndex,
+            endByte: treeNode.endIndex,
+            startPoint: treeNode.startPosition,
+            endPoint: treeNode.endPosition,
+            sourceHash,
+            parser: parseResult.parser,
+            parserVersion: parseResult.parserVersion,
+            metadata: metadataForTreeNode(treeNode, sourceBuffer)
+        });
+    }
+}
+function makeNode({ repositoryId, fileId, relativePath, kind, type, name, startByte, endByte, startPoint, endPoint, sourceHash, parser, parserVersion, metadata }) {
+    const id = hashParts([
+        repositoryId,
+        fileId,
+        relativePath,
+        parserVersion,
+        kind,
+        type,
+        name ?? '',
+        startByte,
+        endByte
+    ]);
+    return {
+        id,
+        kind,
+        type,
+        name,
+        startByte,
+        endByte,
+        startPoint,
+        endPoint,
+        sourceHash,
+        parser,
+        parserVersion,
+        metadata: {
+            ...metadata,
+            lineageKey: hashParts([repositoryId, relativePath, kind, type, name ?? ''])
+        },
+        lastModifiedUserId: null
+    };
+}
+function makeEdge(repositoryId, fileId, sourceId, targetId, kind, metadata) {
+    return {
+        id: hashParts([repositoryId, fileId, sourceId, targetId, kind, JSON.stringify(metadata ?? {})]),
+        sourceId,
+        targetId,
+        kind,
+        confidence: confidenceFor(kind),
+        metadata
+    };
+}
+function kindForTreeNode(node) {
+    if (node.type === 'import_statement')
+        return 'import';
+    if (node.type === 'export_statement')
+        return 'export';
+    if (node.type === 'call_expression')
+        return 'call';
+    return 'symbol';
+}
+function edgeKindFor(parentNode, childNode) {
+    if (parentNode.kind === 'file' && childNode.kind === 'symbol')
+        return 'defines';
+    if (childNode.kind === 'import')
+        return 'contains';
+    if (childNode.kind === 'export')
+        return 'contains';
+    if (childNode.kind === 'call')
+        return 'contains';
+    return 'contains';
+}
+function confidenceFor(kind) {
+    if (kind === 'calls' || kind === 'imports')
+        return 0.65;
+    return 1;
+}
+function nameForTreeNode(node, sourceBuffer) {
+    const namedField = node.childForFieldName('name');
+    if (namedField)
+        return textFor(namedField, sourceBuffer).trim();
+    if (node.type === 'import_statement') {
+        const source = node.childForFieldName('source');
+        return source ? stripQuotes(textFor(source, sourceBuffer).trim()) : textFor(node, sourceBuffer).trim().slice(0, 120);
+    }
+    if (node.type === 'call_expression') {
+        const fn = node.childForFieldName('function');
+        return fn ? textFor(fn, sourceBuffer).trim().slice(0, 120) : textFor(node, sourceBuffer).trim().slice(0, 120);
+    }
+    if (node.type === 'export_statement') {
+        return (textFor(node, sourceBuffer).trim().split('\n')[0] ?? '').slice(0, 120);
+    }
+    return null;
+}
+function metadataForTreeNode(node, sourceBuffer) {
+    if (node.type === 'import_statement') {
+        const source = node.childForFieldName('source');
+        return {
+            module: source ? stripQuotes(textFor(source, sourceBuffer).trim()) : null,
+            snippet: textFor(node, sourceBuffer).trim().slice(0, 240)
+        };
+    }
+    if (node.type === 'call_expression') {
+        const fn = node.childForFieldName('function');
+        return {
+            callee: fn ? textFor(fn, sourceBuffer).trim().slice(0, 120) : null,
+            snippet: textFor(node, sourceBuffer).trim().slice(0, 240)
+        };
+    }
+    return { snippet: textFor(node, sourceBuffer).trim().slice(0, 240) };
+}
+function textFor(node, sourceBuffer) {
+    return sourceBuffer.subarray(node.startIndex, node.endIndex).toString('utf8');
+}
+function stripQuotes(value) {
+    return value.replace(/^['\"]|['\"]$/g, '');
+}
+export function hashParts(parts) {
+    return createHash('sha256')
+        .update(parts.map((part) => String(part)).join('\0'))
+        .digest('hex')
+        .slice(0, 32);
+}
+//# sourceMappingURL=extract.js.map

package/dist/src/graph/repository.d.ts

@@ -0,0 +1,93 @@
+import type { GraphEdgeRow, GraphNodeRow, GraphNodeTextRow, NeighborRow, CallGraphMatch, RepositoryRecord, ScanSummary, StatusResult, StorageScope, ContextGraphResult } from '../types.js';
+export declare function repositoryForRoot(root?: string | undefined): RepositoryRecord;
+export declare function initGraph({ root, scope }?: {
+    root?: string | undefined;
+    scope?: StorageScope | 'both' | undefined;
+}): {
+    repository: RepositoryRecord;
+    initialized: Array<{
+        scope: StorageScope;
+        databasePath: string;
+    }>;
+};
+export declare function scanRepository({ root, scope }?: {
+    root?: string | undefined;
+    scope?: StorageScope | 'both' | undefined;
+}): Promise<ScanSummary>;
+export declare function graphStatus({ root, scope }?: {
+    root?: string | undefined;
+    scope?: StorageScope | 'both' | undefined;
+}): Array<{
+    scope: StorageScope;
+    databasePath: string;
+} & StatusResult>;
+export declare function listNodes({ root, scope, kind, limit }?: {
+    root?: string | undefined;
+    scope?: StorageScope | 'both' | undefined;
+    kind?: string | undefined;
+    limit?: number | undefined;
+}): Array<{
+    scope: StorageScope;
+} & GraphNodeRow>;
+export declare function listNodeText({ root, scope, kind, term, limit }?: {
+    root?: string | undefined;
+    scope?: StorageScope | 'both' | undefined;
+    kind?: string | undefined;
+    term?: string | undefined;
+    limit?: number | undefined;
+}): Array<{
+    scope: StorageScope;
+    root: string;
+} & GraphNodeTextRow>;
+export declare function listEdges({ root, scope, kind, limit }?: {
+    root?: string | undefined;
+    scope?: StorageScope | 'both' | undefined;
+    kind?: string | undefined;
+    limit?: number | undefined;
+}): Array<{
+    scope: StorageScope;
+} & GraphEdgeRow>;
+export declare function neighbors({ root, scope, nodeId, depth, limit }?: {
+    root?: string | undefined;
+    scope?: StorageScope | 'both' | undefined;
+    nodeId?: string | undefined;
+    depth?: number | undefined;
+    limit?: number | undefined;
+}): Array<{
+    scope: StorageScope;
+} & NeighborRow>;
+export declare function callGraph({ root, scope, term, kind, depth, limit }?: {
+    root?: string | undefined;
+    scope?: StorageScope | 'both' | undefined;
+    term?: string | undefined;
+    kind?: string | undefined;
+    depth?: number | undefined;
+    limit?: number | undefined;
+}): Array<{
+    scope: StorageScope;
+} & CallGraphMatch>;
+export interface ContextGraphOptions {
+    root?: string | undefined;
+    scope?: StorageScope | 'both' | undefined;
+    symbol: string;
+    kind?: string | undefined;
+    file?: string | undefined;
+    depth?: number | undefined;
+    limit?: number | undefined;
+    candidateLimit?: number | undefined;
+    excerptLines?: number | undefined;
+    excerptBytes?: number | undefined;
+    excerpts?: boolean | undefined;
+}
+export declare function contextGraph(options: ContextGraphOptions): Promise<ContextGraphResult>;
+export declare function runReadOnlySql({ root, scope, sql, attachHome, limit }?: {
+    root?: string | undefined;
+    scope?: StorageScope | 'both' | undefined;
+    sql?: string | undefined;
+    attachHome?: boolean | undefined;
+    limit?: number | undefined;
+}): Array<{
+    scope: StorageScope;
+    rows: unknown[];
+}>;
+//# sourceMappingURL=repository.d.ts.map