sneakoscope 7.3.0 → 7.6.0

package/dist/core/triwiki/context-graph/extractors/code/builders.js

@@ -0,0 +1,150 @@
+import { lintError } from '../../contracts.js';
+import { compareContextGraphIds, contextGraphEdgeId } from '../../ids.js';
+import { isWorkspaceRelativePosixPath } from '../../paths.js';
+import { CODE_GRAPH_EXTRACTOR_ID } from './types.js';
+export class CodeGraphSink {
+    limits;
+    observedAt;
+    nodes = new Map();
+    edges = new Map();
+    skips = [];
+    skipKeys = new Set();
+    issues = [];
+    nodeCapReported = false;
+    edgeCapReported = false;
+    constructor(limits, observedAt) {
+        this.limits = limits;
+        this.observedAt = observedAt;
+    }
+    get nodeCount() {
+        return this.nodes.size;
+    }
+    get edgeCount() {
+        return this.edges.size;
+    }
+    hasNode(id) {
+        return this.nodes.has(id);
+    }
+    addNode(input, capPath) {
+        if (this.nodes.has(input.id))
+            return true;
+        if (input.path !== undefined && !isWorkspaceRelativePosixPath(input.path)) {
+            this.issues.push(lintError('absolute_or_escaping_path', `node ${input.id} carries a non workspace-relative path`, {
+                nodeId: input.id,
+                extractor: CODE_GRAPH_EXTRACTOR_ID
+            }));
+            return false;
+        }
+        if (this.nodes.size >= this.limits.maxNodes) {
+            if (!this.nodeCapReported) {
+                this.nodeCapReported = true;
+                this.addSkip({ path: capPath, reason: 'cap_reached', detail: `maxNodes=${this.limits.maxNodes} reached` });
+            }
+            return false;
+        }
+        const node = {
+            id: input.id,
+            kind: input.kind,
+            label: input.label,
+            ...(input.path === undefined ? {} : { path: input.path }),
+            ...(input.locator === undefined ? {} : { locator: input.locator }),
+            ...(input.contentHash === undefined ? {} : { contentHash: input.contentHash }),
+            trust: input.trust,
+            freshness: 'fresh',
+            risk: input.risk,
+            tokenCost: input.tokenCost,
+            metadata: input.metadata
+        };
+        this.nodes.set(node.id, node);
+        return true;
+    }
+    addEdge(input) {
+        if (!this.nodes.has(input.from) || !this.nodes.has(input.to))
+            return false;
+        if (!input.path || !isWorkspaceRelativePosixPath(input.path) || !input.hash) {
+            this.issues.push(lintError('edge_without_provenance', `refused a ${input.type} edge without usable provenance`, {
+                extractor: CODE_GRAPH_EXTRACTOR_ID
+            }));
+            return false;
+        }
+        const id = contextGraphEdgeId({ from: input.from, to: input.to, type: input.type });
+        if (this.edges.has(id))
+            return true;
+        if (this.edges.size >= this.limits.maxEdges) {
+            if (!this.edgeCapReported) {
+                this.edgeCapReported = true;
+                this.addSkip({ path: input.path, reason: 'cap_reached', detail: `maxEdges=${this.limits.maxEdges} reached` });
+            }
+            return false;
+        }
+        const line = typeof input.line === 'number' && Number.isFinite(input.line) && input.line > 0 ? Math.trunc(input.line) : undefined;
+        this.edges.set(id, {
+            id,
+            from: input.from,
+            to: input.to,
+            type: input.type,
+            confidence: input.confidence,
+            provenance: {
+                path: input.path,
+                ...(line === undefined ? {} : { line }),
+                hash: input.hash,
+                extractor: CODE_GRAPH_EXTRACTOR_ID
+            },
+            observedAt: this.observedAt
+        });
+        return true;
+    }
+    addSkip(skip) {
+        if (!isWorkspaceRelativePosixPath(skip.path))
+            return;
+        const key = `${skip.path}\u0000${skip.reason}\u0000${skip.detail ?? ''}`;
+        if (this.skipKeys.has(key))
+            return;
+        this.skipKeys.add(key);
+        this.skips.push(skip);
+    }
+    addIssue(issue) {
+        this.issues.push(issue);
+    }
+    pruneUnreachableSymbols() {
+        const reachable = new Set();
+        for (const edge of this.edges.values()) {
+            if (edge.type === 'contains')
+                continue;
+            reachable.add(edge.from);
+            reachable.add(edge.to);
+        }
+        const dropped = new Set();
+        for (const [id, node] of this.nodes) {
+            if (node.kind !== 'symbol')
+                continue;
+            if (node.metadata.exported === true || reachable.has(id))
+                continue;
+            dropped.add(id);
+            this.nodes.delete(id);
+        }
+        if (!dropped.size)
+            return;
+        for (const [id, edge] of this.edges) {
+            if (dropped.has(edge.from) || dropped.has(edge.to))
+                this.edges.delete(id);
+        }
+    }
+    result() {
+        this.pruneUnreachableSymbols();
+        const nodes = [...this.nodes.values()].sort((left, right) => compareContextGraphIds(left.id, right.id));
+        const edges = [...this.edges.values()].sort((left, right) => compareContextGraphIds(left.id, right.id));
+        const skipped = [...this.skips].sort((left, right) => compareContextGraphIds(left.path, right.path) || compareContextGraphIds(left.reason, right.reason) || compareContextGraphIds(left.detail ?? '', right.detail ?? ''));
+        const issues = [...this.issues].sort((left, right) => compareContextGraphIds(left.code, right.code) || compareContextGraphIds(left.message, right.message));
+        return { nodes, edges, issues, skipped };
+    }
+}
+export function riskFromFanIn(fanIn, isTest) {
+    if (isTest)
+        return 'low';
+    if (fanIn >= 5)
+        return 'high';
+    if (fanIn >= 2)
+        return 'medium';
+    return 'low';
+}

package/dist/core/triwiki/context-graph/extractors/code/declarations.js

@@ -0,0 +1,161 @@
+import ts from 'typescript';
+import { contextGraphNodeId } from '../../ids.js';
+import { estimateTokenCost } from './types.js';
+function hasFlag(node, flag) {
+    return (ts.getCombinedModifierFlags(node) & flag) !== 0;
+}
+function collectLocalExportAliases(sourceFile) {
+    const aliases = new Map();
+    for (const statement of sourceFile.statements) {
+        if (!ts.isExportDeclaration(statement))
+            continue;
+        if (statement.moduleSpecifier)
+            continue;
+        const clause = statement.exportClause;
+        if (!clause || !ts.isNamedExports(clause))
+            continue;
+        for (const element of clause.elements) {
+            const local = (element.propertyName ?? element.name).text;
+            const exported = element.name.text;
+            const bucket = aliases.get(local);
+            if (bucket)
+                bucket.push(exported);
+            else
+                aliases.set(local, [exported]);
+        }
+    }
+    return aliases;
+}
+function pushSymbol(context, node, name, symbolKind, options) {
+    const startOffset = node.getStart(context.sourceFile);
+    const endOffset = node.getEnd();
+    const start = context.sourceFile.getLineAndCharacterOfPosition(startOffset);
+    const end = context.sourceFile.getLineAndCharacterOfPosition(endOffset);
+    const exportNames = new Set();
+    if (options.explicitExportNames)
+        for (const explicit of options.explicitExportNames)
+            exportNames.add(explicit);
+    else if (options.isDefault)
+        exportNames.add('default');
+    else if (options.exportedByModifier)
+        exportNames.add(name);
+    for (const alias of context.localExports.get(name) ?? [])
+        exportNames.add(alias);
+    context.out.push({
+        nodeId: contextGraphNodeId({ kind: 'symbol', path: context.rel, symbolKind, name, startOffset }),
+        name,
+        symbolKind,
+        startOffset,
+        endOffset,
+        line: start.line + 1,
+        column: start.character + 1,
+        endLine: end.line + 1,
+        endColumn: end.character + 1,
+        exported: exportNames.size > 0,
+        isDefault: options.isDefault,
+        exportNames: [...exportNames].sort(),
+        tokenCost: estimateTokenCost(endOffset - startOffset)
+    });
+}
+function variableKind(statement) {
+    const flags = statement.declarationList.flags;
+    if (flags & ts.NodeFlags.Const)
+        return 'const';
+    if (flags & ts.NodeFlags.Let)
+        return 'let';
+    return 'var';
+}
+function collectBindingNames(name, out) {
+    if (ts.isIdentifier(name)) {
+        out.push(name);
+        return;
+    }
+    for (const element of name.elements) {
+        if (ts.isOmittedExpression(element))
+            continue;
+        collectBindingNames(element.name, out);
+    }
+}
+function visitVariableStatement(context, statement) {
+    const symbolKind = variableKind(statement);
+    for (const declaration of statement.declarationList.declarations) {
+        const exported = hasFlag(declaration, ts.ModifierFlags.Export);
+        const identifiers = [];
+        collectBindingNames(declaration.name, identifiers);
+        for (const identifier of identifiers) {
+            const anchor = ts.isIdentifier(declaration.name) ? declaration : identifier;
+            pushSymbol(context, anchor, identifier.text, symbolKind, { exportedByModifier: exported, isDefault: false });
+        }
+    }
+}
+function namedDeclarationKind(statement) {
+    if (ts.isFunctionDeclaration(statement))
+        return 'function';
+    if (ts.isClassDeclaration(statement))
+        return 'class';
+    if (ts.isInterfaceDeclaration(statement))
+        return 'interface';
+    if (ts.isTypeAliasDeclaration(statement))
+        return 'type';
+    if (ts.isEnumDeclaration(statement))
+        return 'enum';
+    if (ts.isModuleDeclaration(statement) && ts.isIdentifier(statement.name))
+        return 'namespace';
+    return null;
+}
+function visitStatement(context, statement) {
+    if (ts.isVariableStatement(statement)) {
+        visitVariableStatement(context, statement);
+        return;
+    }
+    if (ts.isExportAssignment(statement)) {
+        const isEquals = statement.isExportEquals === true;
+        const expression = statement.expression;
+        const name = isEquals ? (ts.isIdentifier(expression) ? expression.text : 'exportEquals') : 'default';
+        pushSymbol(context, statement, name, 'default', {
+            exportedByModifier: true,
+            isDefault: !isEquals,
+            ...(isEquals ? { explicitExportNames: ['export=', 'default'] } : {})
+        });
+        return;
+    }
+    const kind = namedDeclarationKind(statement);
+    if (!kind)
+        return;
+    const declaration = statement;
+    const isDefault = hasFlag(declaration, ts.ModifierFlags.Default);
+    const exported = hasFlag(declaration, ts.ModifierFlags.Export);
+    const name = declaration.name && ts.isIdentifier(declaration.name) ? declaration.name.text : isDefault ? 'default' : '';
+    if (!name)
+        return;
+    pushSymbol(context, statement, name, kind, { exportedByModifier: exported, isDefault });
+}
+export function extractDeclarations(sourceFile, rel) {
+    const context = {
+        sourceFile,
+        rel,
+        localExports: collectLocalExportAliases(sourceFile),
+        out: []
+    };
+    for (const statement of sourceFile.statements)
+        visitStatement(context, statement);
+    return context.out;
+}
+export function indexExports(symbols) {
+    const index = new Map();
+    for (const symbol of symbols) {
+        for (const exportName of symbol.exportNames) {
+            if (!index.has(exportName))
+                index.set(exportName, symbol);
+        }
+    }
+    return index;
+}
+export function indexDeclaredNames(symbols) {
+    const index = new Map();
+    for (const symbol of symbols) {
+        if (!index.has(symbol.name))
+            index.set(symbol.name, symbol);
+    }
+    return index;
+}

package/dist/core/triwiki/context-graph/extractors/code/index.js

@@ -0,0 +1,265 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { emptyContextGraphFragment, lintWarning } from '../../contracts.js';
+import { contextGraphNodeId } from '../../ids.js';
+import { CodeGraphSink, riskFromFanIn } from './builders.js';
+import { extractDeclarations, indexDeclaredNames, indexExports } from './declarations.js';
+import { walkCodeInventory } from './inventory.js';
+import { buildImportAndReexportEdges, collectModuleFacts } from './module-graph.js';
+import { buildModuleContainsEdges, buildModuleNodes, inferModuleBoundaries, moduleDirForPath } from './modules.js';
+import { buildReferenceEdges } from './references.js';
+import { selectExtractionTargets } from './selection.js';
+import { createCodeSourceFile, createResolutionContext } from './ts-config.js';
+import { CODE_GRAPH_EXTRACTOR_ID, CODE_GRAPH_EXTRACTOR_REVISION, estimateTokenCost } from './types.js';
+const MAX_UNRESOLVED_WARNINGS = 100;
+function realRoot(root) {
+    const absolute = path.resolve(root);
+    try {
+        return fs.realpathSync(absolute);
+    }
+    catch {
+        return absolute;
+    }
+}
+function sortedHashes(hashes) {
+    const out = {};
+    for (const key of [...hashes.keys()].sort()) {
+        const value = hashes.get(key);
+        if (value !== undefined)
+            out[key] = value;
+    }
+    return out;
+}
+export class CodeGraphExtractor {
+    id = CODE_GRAPH_EXTRACTOR_ID;
+    revision = CODE_GRAPH_EXTRACTOR_REVISION;
+    async extract(input) {
+        const startedAt = Date.now();
+        const deadline = startedAt + Math.max(1, input.limits.timeoutMs);
+        const root = realRoot(input.root);
+        const sink = new CodeGraphSink(input.limits, input.observedAt);
+        const inventory = walkCodeInventory(root, input.limits);
+        for (const skip of inventory.skipped)
+            sink.addSkip(skip);
+        const hashes = new Map();
+        for (const file of inventory.files)
+            hashes.set(file.rel, file.hash);
+        const context = createResolutionContext(root);
+        if (context.configRel && context.configHash)
+            hashes.set(context.configRel, context.configHash);
+        const selection = selectExtractionTargets(context, inventory, input.changedPaths);
+        for (const unknown of selection.unknownChanged) {
+            sink.addIssue(lintWarning('extractor_skipped_input', 'changed path is not a scannable source file', {
+                path: unknown,
+                extractor: this.id
+            }));
+        }
+        if (selection.unmappableChanged > 0) {
+            sink.addIssue(lintWarning('extractor_skipped_input', `${selection.unmappableChanged} changed path(s) are outside the workspace`, {
+                extractor: this.id
+            }));
+        }
+        const phase = this.parseAndCollect(context, inventory, selection.targets, sink, deadline);
+        this.reportUnresolved(sink, phase.factsByRel);
+        const fanIn = countFanIn(phase.factsByRel);
+        const nodeRels = collectNodeRels(phase.factsByRel, phase.parsedByRel, inventory);
+        const fileNodeIdByRel = new Map();
+        const testNodeIdByRel = new Map();
+        this.buildFileNodes({ sink, inventory, nodeRels, parsed: phase.parsedByRel, fanIn, fileNodeIdByRel, testNodeIdByRel });
+        this.buildSymbolNodes(sink, inventory, phase.declarationsByRel);
+        const boundaries = inferModuleBoundaries([...fileNodeIdByRel.keys()].sort());
+        buildModuleNodes(sink, boundaries);
+        buildModuleContainsEdges(sink, boundaries, fileNodeIdByRel, inventory.byRel);
+        this.buildContainmentEdges(sink, inventory, phase.declarationsByRel, fileNodeIdByRel, testNodeIdByRel);
+        buildImportAndReexportEdges(sink, phase.tables, inventory.byRel, fileNodeIdByRel);
+        buildReferenceEdges(sink, {
+            tables: phase.tables,
+            parsedByRel: phase.parsedByRel,
+            byRel: inventory.byRel,
+            fileNodeIdByRel,
+            testNodeIdByRel
+        });
+        const result = sink.result();
+        const fragment = emptyContextGraphFragment(this.id, this.revision);
+        fragment.nodes = result.nodes;
+        fragment.edges = result.edges;
+        fragment.issues = result.issues;
+        fragment.skipped = result.skipped;
+        fragment.inputHashes = sortedHashes(hashes);
+        return fragment;
+    }
+    parseAndCollect(context, inventory, targets, sink, deadline) {
+        const parsedByRel = new Map();
+        const factsByRel = new Map();
+        const declarationsByRel = new Map();
+        const exportsByRel = new Map();
+        const declaredByRel = new Map();
+        const isKnownFile = (rel) => inventory.byRel.has(rel);
+        for (const record of targets) {
+            if (Date.now() >= deadline) {
+                sink.addSkip({ path: record.rel, reason: 'cap_reached', detail: 'timeoutMs exceeded before parse' });
+                break;
+            }
+            const parsed = { record, sourceFile: createCodeSourceFile(context, record) };
+            parsedByRel.set(record.rel, parsed);
+            const facts = collectModuleFacts(context, parsed, isKnownFile);
+            factsByRel.set(record.rel, facts);
+            for (const skip of facts.skips)
+                sink.addSkip(skip);
+            const declarations = extractDeclarations(parsed.sourceFile, record.rel);
+            declarationsByRel.set(record.rel, declarations);
+            exportsByRel.set(record.rel, indexExports(declarations));
+            declaredByRel.set(record.rel, indexDeclaredNames(declarations));
+        }
+        return { parsedByRel, factsByRel, declarationsByRel, tables: { factsByRel, exportsByRel, declaredByRel } };
+    }
+    reportUnresolved(sink, factsByRel) {
+        let reported = 0;
+        for (const [rel, facts] of factsByRel) {
+            for (const entry of facts.unresolved) {
+                if (reported >= MAX_UNRESOLVED_WARNINGS)
+                    return;
+                reported += 1;
+                sink.addIssue(lintWarning('extractor_skipped_input', `unresolved first-party import '${entry.specifier}'`, {
+                    path: rel,
+                    extractor: this.id
+                }));
+            }
+        }
+    }
+    buildFileNodes(args) {
+        for (const rel of args.nodeRels) {
+            const record = args.inventory.byRel.get(rel);
+            if (!record)
+                continue;
+            const scanned = args.parsed.has(rel);
+            const id = contextGraphNodeId({ kind: 'file', path: rel });
+            const added = args.sink.addNode({
+                id,
+                kind: 'file',
+                label: path.posix.basename(rel),
+                path: rel,
+                contentHash: record.hash,
+                trust: 1,
+                risk: riskFromFanIn(args.fanIn.get(rel) ?? 0, record.isTest),
+                tokenCost: estimateTokenCost(record.bytes),
+                metadata: {
+                    extension: record.extension,
+                    language: record.language,
+                    lines: record.lines,
+                    bytes: record.bytes,
+                    isTest: record.isTest,
+                    fanIn: args.fanIn.get(rel) ?? 0,
+                    scanned
+                }
+            }, rel);
+            if (!added)
+                continue;
+            args.fileNodeIdByRel.set(rel, id);
+            if (!record.isTest || !scanned)
+                continue;
+            const testId = contextGraphNodeId({ kind: 'test', path: rel });
+            if (args.sink.addNode({
+                id: testId,
+                kind: 'test',
+                label: path.posix.basename(rel),
+                path: rel,
+                contentHash: record.hash,
+                trust: 1,
+                risk: 'low',
+                tokenCost: estimateTokenCost(record.bytes),
+                metadata: { lines: record.lines, bytes: record.bytes, suite: 'file' }
+            }, rel)) {
+                args.testNodeIdByRel.set(rel, testId);
+            }
+        }
+    }
+    buildSymbolNodes(sink, inventory, declarationsByRel) {
+        for (const rel of [...declarationsByRel.keys()].sort()) {
+            const record = inventory.byRel.get(rel);
+            const declarations = declarationsByRel.get(rel);
+            if (!record || !declarations)
+                continue;
+            const moduleDir = moduleDirForPath(rel);
+            for (const symbol of declarations) {
+                sink.addNode({
+                    id: symbol.nodeId,
+                    kind: 'symbol',
+                    label: symbol.name,
+                    path: rel,
+                    contentHash: record.hash,
+                    locator: { line: symbol.line, column: symbol.column, endLine: symbol.endLine, endColumn: symbol.endColumn },
+                    trust: 1,
+                    risk: 'low',
+                    tokenCost: symbol.tokenCost,
+                    metadata: {
+                        symbolKind: symbol.symbolKind,
+                        exported: symbol.exported,
+                        default: symbol.isDefault,
+                        exportNames: symbol.exportNames,
+                        module: moduleDir
+                    }
+                }, rel);
+            }
+        }
+    }
+    buildContainmentEdges(sink, inventory, declarationsByRel, fileNodeIdByRel, testNodeIdByRel) {
+        for (const rel of [...declarationsByRel.keys()].sort()) {
+            const record = inventory.byRel.get(rel);
+            const from = fileNodeIdByRel.get(rel);
+            const declarations = declarationsByRel.get(rel);
+            if (!record || !from || !declarations)
+                continue;
+            const testNodeId = testNodeIdByRel.get(rel);
+            if (testNodeId) {
+                sink.addEdge({ from, to: testNodeId, type: 'contains', confidence: 'exact', path: rel, hash: record.hash });
+            }
+            for (const symbol of declarations) {
+                sink.addEdge({
+                    from,
+                    to: symbol.nodeId,
+                    type: 'contains',
+                    confidence: 'exact',
+                    path: rel,
+                    hash: record.hash,
+                    line: symbol.line
+                });
+                if (!symbol.exported)
+                    continue;
+                sink.addEdge({
+                    from,
+                    to: symbol.nodeId,
+                    type: 'defines',
+                    confidence: 'exact',
+                    path: rel,
+                    hash: record.hash,
+                    line: symbol.line
+                });
+            }
+        }
+    }
+}
+function countFanIn(factsByRel) {
+    const fanIn = new Map();
+    for (const facts of factsByRel.values()) {
+        for (const entry of facts.imports)
+            fanIn.set(entry.targetRel, (fanIn.get(entry.targetRel) ?? 0) + 1);
+    }
+    return fanIn;
+}
+function collectNodeRels(factsByRel, parsedByRel, inventory) {
+    const rels = new Set(parsedByRel.keys());
+    for (const facts of factsByRel.values()) {
+        for (const entry of facts.imports)
+            if (inventory.byRel.has(entry.targetRel))
+                rels.add(entry.targetRel);
+        for (const record of facts.reexports)
+            if (inventory.byRel.has(record.targetRel))
+                rels.add(record.targetRel);
+    }
+    return [...rels].sort();
+}
+export function createCodeGraphExtractor() {
+    return new CodeGraphExtractor();
+}
+export { CODE_GRAPH_EXTRACTOR_ID, CODE_GRAPH_EXTRACTOR_REVISION } from './types.js';