sneakoscope 7.3.0 → 7.6.0

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

@@ -0,0 +1,184 @@
+import ts from 'typescript';
+import { resolveExportedSymbol } from './module-graph.js';
+function isUsageIdentifier(node) {
+    const parent = node.parent;
+    if (!parent)
+        return false;
+    if (ts.isPropertyAccessExpression(parent) && parent.name === node)
+        return false;
+    if (ts.isQualifiedName(parent) && parent.right === node)
+        return false;
+    if (ts.isPropertyAssignment(parent) && parent.name === node)
+        return false;
+    if (ts.isPropertySignature(parent) && parent.name === node)
+        return false;
+    if (ts.isPropertyDeclaration(parent) && parent.name === node)
+        return false;
+    if (ts.isMethodDeclaration(parent) && parent.name === node)
+        return false;
+    if (ts.isMethodSignature(parent) && parent.name === node)
+        return false;
+    if (ts.isEnumMember(parent) && parent.name === node)
+        return false;
+    if (ts.isBindingElement(parent) && (parent.name === node || parent.propertyName === node))
+        return false;
+    if (ts.isParameter(parent) && parent.name === node)
+        return false;
+    if (ts.isVariableDeclaration(parent) && parent.name === node)
+        return false;
+    if (ts.isFunctionDeclaration(parent) && parent.name === node)
+        return false;
+    if (ts.isClassDeclaration(parent) && parent.name === node)
+        return false;
+    if (ts.isInterfaceDeclaration(parent) && parent.name === node)
+        return false;
+    if (ts.isTypeAliasDeclaration(parent) && parent.name === node)
+        return false;
+    if (ts.isEnumDeclaration(parent) && parent.name === node)
+        return false;
+    if (ts.isModuleDeclaration(parent) && parent.name === node)
+        return false;
+    if (ts.isLabeledStatement(parent) && parent.label === node)
+        return false;
+    return true;
+}
+function isInvoked(node) {
+    const parent = node.parent;
+    if (!parent)
+        return false;
+    if (ts.isCallExpression(parent) && parent.expression === node)
+        return true;
+    if (ts.isNewExpression(parent) && parent.expression === node)
+        return true;
+    if (ts.isTaggedTemplateExpression(parent) && parent.tag === node)
+        return true;
+    return false;
+}
+function recordUsage(usages, binding, exportName, line, call) {
+    const key = `${binding.local}|${exportName}`;
+    const existing = usages.get(key);
+    if (!existing) {
+        usages.set(key, { binding, exportName, line, callLine: call ? line : null });
+        return;
+    }
+    if (call && existing.callLine === null)
+        existing.callLine = line;
+}
+function collectUsages(parsed, bindings) {
+    const usages = new Map();
+    const byLocal = new Map();
+    for (const binding of bindings)
+        if (!byLocal.has(binding.local))
+            byLocal.set(binding.local, binding);
+    if (!byLocal.size)
+        return usages;
+    const sourceFile = parsed.sourceFile;
+    const handle = (node) => {
+        const binding = byLocal.get(node.text);
+        if (!binding || !binding.targetRel)
+            return;
+        if (!isUsageIdentifier(node))
+            return;
+        const line = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+        const parent = node.parent;
+        if (binding.exportName === '*') {
+            if (!parent || !ts.isPropertyAccessExpression(parent) || parent.expression !== node)
+                return;
+            if (!ts.isIdentifier(parent.name))
+                return;
+            recordUsage(usages, binding, parent.name.text, line, isInvoked(parent));
+            return;
+        }
+        recordUsage(usages, binding, binding.exportName, line, isInvoked(node));
+    };
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node) || ts.isImportEqualsDeclaration(node) || ts.isExportDeclaration(node))
+            return;
+        if (ts.isIdentifier(node)) {
+            handle(node);
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    return usages;
+}
+function resolveUsage(tables, usage) {
+    const targetRel = usage.binding.targetRel;
+    if (!targetRel)
+        return null;
+    const resolved = resolveExportedSymbol(tables, targetRel, usage.exportName);
+    if (resolved)
+        return { symbolNodeId: resolved.symbol.nodeId, definingRel: resolved.rel, confidence: 'exact' };
+    const declared = tables.declaredByRel.get(targetRel)?.get(usage.exportName);
+    if (declared)
+        return { symbolNodeId: declared.nodeId, definingRel: targetRel, confidence: 'syntactic' };
+    return null;
+}
+export function buildReferenceEdges(sink, inputs) {
+    const rels = [...inputs.parsedByRel.keys()].sort();
+    for (const rel of rels) {
+        const parsed = inputs.parsedByRel.get(rel);
+        const record = inputs.byRel.get(rel);
+        const from = inputs.fileNodeIdByRel.get(rel);
+        const facts = inputs.tables.factsByRel.get(rel);
+        if (!parsed || !record || !from || !facts)
+            continue;
+        const testNodeId = inputs.testNodeIdByRel.get(rel);
+        for (const usage of collectUsages(parsed, facts.bindings).values()) {
+            const resolved = resolveUsage(inputs.tables, usage);
+            if (!resolved)
+                continue;
+            sink.addEdge({
+                from,
+                to: resolved.symbolNodeId,
+                type: 'references',
+                confidence: resolved.confidence,
+                path: rel,
+                hash: record.hash,
+                line: usage.line
+            });
+            if (usage.callLine !== null) {
+                sink.addEdge({
+                    from,
+                    to: resolved.symbolNodeId,
+                    type: 'calls',
+                    confidence: resolved.confidence,
+                    path: rel,
+                    hash: record.hash,
+                    line: usage.callLine
+                });
+            }
+            if (testNodeId && !inputs.byRel.get(resolved.definingRel)?.isTest) {
+                sink.addEdge({
+                    from: testNodeId,
+                    to: resolved.symbolNodeId,
+                    type: 'tests',
+                    confidence: resolved.confidence,
+                    path: rel,
+                    hash: record.hash,
+                    line: usage.line
+                });
+            }
+        }
+        if (!testNodeId)
+            continue;
+        for (const entry of facts.imports) {
+            const target = inputs.byRel.get(entry.targetRel);
+            if (!target || target.isTest)
+                continue;
+            const to = inputs.fileNodeIdByRel.get(entry.targetRel);
+            if (!to)
+                continue;
+            sink.addEdge({
+                from: testNodeId,
+                to,
+                type: 'tests',
+                confidence: 'exact',
+                path: rel,
+                hash: record.hash,
+                line: entry.line
+            });
+        }
+    }
+}

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

@@ -0,0 +1,100 @@
+import ts from 'typescript';
+import { tryNormalizeGraphPath } from '../../paths.js';
+import { resolveSpecifier } from './ts-config.js';
+function impliedFormat(context, record) {
+    try {
+        return ts.getImpliedNodeFormatForFile(record.abs, context.cache.getPackageJsonInfoCache(), context.host, context.options);
+    }
+    catch {
+        return undefined;
+    }
+}
+function buildForwardDependencies(context, inventory) {
+    const forward = new Map();
+    for (const record of inventory.files) {
+        const mode = impliedFormat(context, record);
+        const targets = new Set();
+        let preprocessed;
+        try {
+            preprocessed = ts.preProcessFile(record.text, true, true);
+        }
+        catch {
+            forward.set(record.rel, []);
+            continue;
+        }
+        for (const reference of preprocessed.importedFiles) {
+            const resolved = resolveSpecifier(context, reference.fileName, record.abs, mode);
+            if (!resolved)
+                continue;
+            const rel = tryNormalizeGraphPath(context.root, resolved.fileName);
+            if (rel === null || !inventory.byRel.has(rel))
+                continue;
+            targets.add(rel);
+        }
+        forward.set(record.rel, [...targets].sort());
+    }
+    return forward;
+}
+function invert(forward) {
+    const reverse = new Map();
+    for (const [from, targets] of forward) {
+        for (const target of targets) {
+            const bucket = reverse.get(target);
+            if (bucket)
+                bucket.push(from);
+            else
+                reverse.set(target, [from]);
+        }
+    }
+    for (const [, importers] of reverse)
+        importers.sort();
+    return reverse;
+}
+export function selectExtractionTargets(context, inventory, changedPaths) {
+    if (changedPaths === null) {
+        return { targets: [...inventory.files], full: true, unknownChanged: [], unmappableChanged: 0 };
+    }
+    const seeds = [];
+    const unknownChanged = [];
+    let unmappableChanged = 0;
+    for (const candidate of changedPaths) {
+        const rel = tryNormalizeGraphPath(context.root, candidate);
+        if (rel === null) {
+            unmappableChanged += 1;
+            continue;
+        }
+        if (inventory.byRel.has(rel))
+            seeds.push(rel);
+        else
+            unknownChanged.push(rel);
+    }
+    const forward = buildForwardDependencies(context, inventory);
+    const reverse = invert(forward);
+    const closure = new Set();
+    const queue = [...new Set(seeds)].sort();
+    for (const seed of queue)
+        closure.add(seed);
+    while (queue.length) {
+        const current = queue.shift();
+        if (current === undefined)
+            break;
+        for (const importer of reverse.get(current) ?? []) {
+            if (closure.has(importer))
+                continue;
+            closure.add(importer);
+            queue.push(importer);
+        }
+    }
+    const selected = new Set(closure);
+    for (const rel of closure) {
+        for (const dependency of forward.get(rel) ?? [])
+            selected.add(dependency);
+    }
+    const targets = inventory.files.filter((record) => selected.has(record.rel));
+    return {
+        targets,
+        full: false,
+        unknownChanged: [...new Set(unknownChanged)].sort(),
+        unmappableChanged
+    };
+}

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

@@ -0,0 +1,161 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import ts from 'typescript';
+const FALLBACK_OPTIONS = {
+    allowJs: true,
+    checkJs: false,
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    jsx: ts.JsxEmit.ReactJSX,
+    resolveJsonModule: false
+};
+export function sanitizeCompilerOptions(options) {
+    const sanitized = { ...options };
+    delete sanitized.plugins;
+    delete sanitized.outFile;
+    delete sanitized.out;
+    delete sanitized.declarationDir;
+    delete sanitized.tsBuildInfoFile;
+    delete sanitized.incremental;
+    delete sanitized.composite;
+    sanitized.noEmit = true;
+    sanitized.declaration = false;
+    sanitized.declarationMap = false;
+    sanitized.sourceMap = false;
+    sanitized.skipLibCheck = true;
+    sanitized.allowJs = true;
+    sanitized.checkJs = false;
+    sanitized.types = [];
+    return sanitized;
+}
+function readConfigOptions(root) {
+    for (const name of ['tsconfig.json', 'jsconfig.json']) {
+        const absolute = path.join(root, name);
+        let raw;
+        try {
+            raw = fs.readFileSync(absolute);
+        }
+        catch {
+            continue;
+        }
+        const read = ts.readConfigFile(absolute, () => raw.toString('utf8'));
+        if (read.error || !read.config)
+            continue;
+        const parsed = ts.parseJsonConfigFileContent(read.config, ts.sys, root, undefined, absolute);
+        return {
+            options: sanitizeCompilerOptions(parsed.options),
+            rel: name,
+            hash: crypto.createHash('sha256').update(raw).digest('hex')
+        };
+    }
+    return { options: sanitizeCompilerOptions(FALLBACK_OPTIONS), rel: null, hash: null };
+}
+function createResolutionHost() {
+    const existsCache = new Map();
+    const dirCache = new Map();
+    const host = {
+        fileExists: (fileName) => {
+            const cached = existsCache.get(fileName);
+            if (cached !== undefined)
+                return cached;
+            const value = ts.sys.fileExists(fileName);
+            existsCache.set(fileName, value);
+            return value;
+        },
+        readFile: (fileName) => ts.sys.readFile(fileName),
+        directoryExists: (directoryName) => {
+            const cached = dirCache.get(directoryName);
+            if (cached !== undefined)
+                return cached;
+            const value = ts.sys.directoryExists(directoryName);
+            dirCache.set(directoryName, value);
+            return value;
+        },
+        getDirectories: (directoryName) => ts.sys.getDirectories(directoryName),
+        useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames
+    };
+    if (typeof ts.sys.realpath === 'function') {
+        const realpath = ts.sys.realpath.bind(ts.sys);
+        host.realpath = (fileName) => realpath(fileName);
+    }
+    return host;
+}
+export function createResolutionContext(root) {
+    const absoluteRoot = path.resolve(root);
+    const config = readConfigOptions(absoluteRoot);
+    const host = createResolutionHost();
+    const canonical = ts.sys.useCaseSensitiveFileNames
+        ? (value) => value
+        : (value) => value.toLowerCase();
+    const cache = ts.createModuleResolutionCache(absoluteRoot, canonical, config.options);
+    return {
+        root: absoluteRoot,
+        options: config.options,
+        configRel: config.rel,
+        configHash: config.hash,
+        host,
+        cache
+    };
+}
+export function scriptKindForPath(relativePath) {
+    const lower = relativePath.toLowerCase();
+    if (lower.endsWith('.tsx'))
+        return ts.ScriptKind.TSX;
+    if (lower.endsWith('.jsx'))
+        return ts.ScriptKind.JSX;
+    if (lower.endsWith('.mts') || lower.endsWith('.cts') || lower.endsWith('.ts'))
+        return ts.ScriptKind.TS;
+    if (lower.endsWith('.mjs') || lower.endsWith('.cjs') || lower.endsWith('.js'))
+        return ts.ScriptKind.JS;
+    return ts.ScriptKind.TS;
+}
+export function createCodeSourceFile(context, record) {
+    let impliedNodeFormat;
+    try {
+        impliedNodeFormat = ts.getImpliedNodeFormatForFile(record.abs, context.cache.getPackageJsonInfoCache(), context.host, context.options);
+    }
+    catch {
+        impliedNodeFormat = undefined;
+    }
+    const options = {
+        languageVersion: context.options.target ?? ts.ScriptTarget.ESNext,
+        ...(impliedNodeFormat === undefined ? {} : { impliedNodeFormat })
+    };
+    return ts.createSourceFile(record.abs, record.text, options, true, scriptKindForPath(record.rel));
+}
+export function modeForSpecifier(context, sourceFile, usage) {
+    try {
+        return ts.getModeForUsageLocation(sourceFile, usage, context.options);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resolveSpecifier(context, specifier, containingFile, mode) {
+    if (!specifier)
+        return null;
+    let resolved;
+    try {
+        resolved = ts.resolveModuleName(specifier, containingFile, context.options, context.host, context.cache, undefined, mode);
+    }
+    catch {
+        return null;
+    }
+    const module = resolved.resolvedModule;
+    if (!module)
+        return null;
+    return { fileName: module.resolvedFileName, external: module.isExternalLibraryImport === true };
+}
+export function isBareSpecifier(specifier) {
+    if (!specifier)
+        return false;
+    if (specifier.startsWith('.'))
+        return false;
+    if (specifier.startsWith('/'))
+        return false;
+    if (/^[A-Za-z]:[\\/]/.test(specifier))
+        return false;
+    return true;
+}

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

@@ -0,0 +1,18 @@
+export const CODE_GRAPH_EXTRACTOR_ID = 'code';
+export const CODE_GRAPH_EXTRACTOR_REVISION = '1.0.0';
+export const MAX_REEXPORT_DEPTH = 8;
+export const CODE_SYMBOL_KINDS = [
+    'function',
+    'class',
+    'interface',
+    'type',
+    'enum',
+    'namespace',
+    'const',
+    'let',
+    'var',
+    'default'
+];
+export function estimateTokenCost(length) {
+    return Math.max(1, Math.ceil(Math.max(0, length) / 4));
+}