sneakoscope 7.3.0 → 7.6.0

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

@@ -0,0 +1,237 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { isSymlinkEscape } from '../../paths.js';
+const EXCLUDED_DIR_NAMES = new Set(['node_modules', 'dist', 'build', 'coverage', 'archive']);
+const SUPPORTED_EXTENSIONS = new Map([
+    ['.ts', 'typescript'],
+    ['.tsx', 'typescript'],
+    ['.mts', 'typescript'],
+    ['.cts', 'typescript'],
+    ['.js', 'javascript'],
+    ['.jsx', 'javascript'],
+    ['.mjs', 'javascript'],
+    ['.cjs', 'javascript']
+]);
+const FOREIGN_CODE_EXTENSIONS = new Set([
+    '.py', '.rb', '.go', '.rs', '.java', '.kt', '.kts', '.swift', '.php', '.c', '.h', '.cc', '.cpp',
+    '.hpp', '.cs', '.scala', '.sh', '.bash', '.zsh', '.vue', '.svelte', '.dart', '.m', '.mm', '.pl',
+    '.lua', '.ex', '.exs', '.clj', '.hs', '.ml', '.jl', '.sql', '.r'
+]);
+const MAX_EXCLUDED_SKIPS = 64;
+const MAX_CAP_SKIPS = 32;
+const BINARY_PROBE_BYTES = 8192;
+const MIN_BINARY_CONTROL_BYTES = 4;
+const MIN_BINARY_CONTROL_PERCENT = 1;
+export function isSupportedCodePath(relativePath) {
+    return SUPPORTED_EXTENSIONS.has(path.posix.extname(relativePath).toLowerCase());
+}
+export function isTestPath(relativePath) {
+    const parts = relativePath.split('/');
+    if (parts.includes('__tests__') || parts.includes('__test__'))
+        return true;
+    const head = parts[0];
+    if (parts.length > 1 && (head === 'test' || head === 'tests'))
+        return true;
+    const base = parts[parts.length - 1] ?? '';
+    return /\.(?:test|spec)\.[cm]?[jt]sx?$/i.test(base);
+}
+function isExcludedDirName(name) {
+    return name.startsWith('.') || EXCLUDED_DIR_NAMES.has(name);
+}
+function hashBytes(bytes) {
+    return crypto.createHash('sha256').update(bytes).digest('hex');
+}
+function countLines(text) {
+    if (!text)
+        return 0;
+    let lines = 1;
+    for (let index = 0; index < text.length; index += 1)
+        if (text.charCodeAt(index) === 10)
+            lines += 1;
+    return text.endsWith('\n') ? lines - 1 : lines;
+}
+function decodeUtf8(bytes) {
+    try {
+        return new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    }
+    catch {
+        return null;
+    }
+}
+function controlByteDensity(bytes) {
+    const probe = Math.min(bytes.length, BINARY_PROBE_BYTES);
+    if (!probe)
+        return { count: 0, percent: 0 };
+    let count = 0;
+    for (let index = 0; index < probe; index += 1) {
+        const byte = bytes[index];
+        if (byte === undefined)
+            continue;
+        if (byte === 0 || byte < 9 || (byte > 13 && byte < 32) || byte === 127)
+            count += 1;
+    }
+    return { count, percent: (count / probe) * 100 };
+}
+function looksBinary(bytes) {
+    const density = controlByteDensity(bytes);
+    return density.count >= MIN_BINARY_CONTROL_BYTES && density.percent >= MIN_BINARY_CONTROL_PERCENT;
+}
+function addSkip(state, skip) {
+    if (skip.reason === 'excluded') {
+        if (state.excludedSkips >= MAX_EXCLUDED_SKIPS)
+            return;
+        state.excludedSkips += 1;
+    }
+    if (skip.reason === 'cap_reached') {
+        if (state.capSkips >= MAX_CAP_SKIPS) {
+            state.stopped = true;
+            return;
+        }
+        state.capSkips += 1;
+    }
+    state.skipped.push(skip);
+}
+function readEntries(absolute) {
+    try {
+        return fs.readdirSync(absolute, { withFileTypes: true }).sort((left, right) => (left.name < right.name ? -1 : left.name > right.name ? 1 : 0));
+    }
+    catch {
+        return null;
+    }
+}
+function ingestFile(state, rel, absolute) {
+    const extension = path.posix.extname(rel).toLowerCase();
+    const language = SUPPORTED_EXTENSIONS.get(extension);
+    if (!language) {
+        if (FOREIGN_CODE_EXTENSIONS.has(extension)) {
+            addSkip(state, { path: rel, reason: 'unsupported_language', detail: `no extractor for ${extension} sources` });
+        }
+        return;
+    }
+    if (isSymlinkEscape(state.root, rel)) {
+        addSkip(state, { path: rel, reason: 'symlink_escape', detail: 'symlink resolves outside the workspace' });
+        return;
+    }
+    if (state.files.length >= state.limits.maxFiles) {
+        addSkip(state, { path: rel, reason: 'cap_reached', detail: `maxFiles=${state.limits.maxFiles} reached` });
+        return;
+    }
+    let stat;
+    try {
+        stat = fs.statSync(absolute);
+    }
+    catch {
+        addSkip(state, { path: rel, reason: 'unreadable', detail: 'stat failed' });
+        return;
+    }
+    if (stat.size > state.limits.maxFileBytes) {
+        addSkip(state, { path: rel, reason: 'oversized', detail: `${stat.size} bytes exceeds maxFileBytes=${state.limits.maxFileBytes}` });
+        return;
+    }
+    let bytes;
+    try {
+        bytes = fs.readFileSync(absolute);
+    }
+    catch {
+        addSkip(state, { path: rel, reason: 'unreadable', detail: 'read failed' });
+        return;
+    }
+    const text = decodeUtf8(bytes);
+    if (text === null) {
+        addSkip(state, { path: rel, reason: 'binary', detail: 'not valid UTF-8 despite a source extension' });
+        return;
+    }
+    if (looksBinary(bytes)) {
+        addSkip(state, { path: rel, reason: 'binary', detail: 'dense control bytes in a source-extension file' });
+        return;
+    }
+    state.files.push({
+        rel,
+        abs: absolute,
+        hash: hashBytes(bytes),
+        text,
+        bytes: bytes.length,
+        lines: countLines(text),
+        isTest: isTestPath(rel),
+        extension,
+        language
+    });
+}
+function walkDirectory(state, relDir) {
+    if (state.stopped)
+        return;
+    const absolute = relDir ? path.join(state.root, relDir) : state.root;
+    let real;
+    try {
+        real = fs.realpathSync(absolute);
+    }
+    catch {
+        addSkip(state, { path: relDir || '.', reason: 'unreadable', detail: 'directory realpath failed' });
+        return;
+    }
+    if (state.visitedDirs.has(real))
+        return;
+    state.visitedDirs.add(real);
+    const entries = readEntries(absolute);
+    if (!entries) {
+        addSkip(state, { path: relDir || '.', reason: 'unreadable', detail: 'directory listing failed' });
+        return;
+    }
+    for (const entry of entries) {
+        if (state.stopped)
+            return;
+        const rel = relDir ? `${relDir}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            if (isExcludedDirName(entry.name)) {
+                addSkip(state, { path: rel, reason: 'excluded', detail: 'directory is not scanned by the code extractor' });
+                continue;
+            }
+            walkDirectory(state, rel);
+            continue;
+        }
+        if (entry.isSymbolicLink()) {
+            let target;
+            try {
+                target = fs.statSync(path.join(state.root, rel));
+            }
+            catch {
+                addSkip(state, { path: rel, reason: 'unreadable', detail: 'broken symlink' });
+                continue;
+            }
+            if (target.isDirectory()) {
+                if (isSymlinkEscape(state.root, rel)) {
+                    addSkip(state, { path: rel, reason: 'symlink_escape', detail: 'symlinked directory resolves outside the workspace' });
+                    continue;
+                }
+                if (isExcludedDirName(entry.name))
+                    continue;
+                walkDirectory(state, rel);
+                continue;
+            }
+        }
+        if (!entry.isFile() && !entry.isSymbolicLink())
+            continue;
+        ingestFile(state, rel, path.join(state.root, rel));
+    }
+}
+export function walkCodeInventory(root, limits) {
+    const absoluteRoot = path.resolve(root);
+    const state = {
+        root: absoluteRoot,
+        limits,
+        files: [],
+        skipped: [],
+        excludedSkips: 0,
+        capSkips: 0,
+        stopped: false,
+        visitedDirs: new Set()
+    };
+    if (fs.existsSync(absoluteRoot))
+        walkDirectory(state, '');
+    state.files.sort((left, right) => (left.rel < right.rel ? -1 : left.rel > right.rel ? 1 : 0));
+    const byRel = new Map();
+    for (const file of state.files)
+        byRel.set(file.rel, file);
+    return { files: state.files, byRel, skipped: state.skipped };
+}

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

@@ -0,0 +1,252 @@
+import ts from 'typescript';
+import { tryNormalizeGraphPath } from '../../paths.js';
+import { isBareSpecifier, modeForSpecifier, resolveSpecifier } from './ts-config.js';
+import { MAX_REEXPORT_DEPTH } from './types.js';
+function lineOf(sourceFile, node) {
+    return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+}
+function resolveTargetRel(builder, literal, line) {
+    const specifier = literal.text;
+    if (!specifier)
+        return null;
+    const mode = modeForSpecifier(builder.context, builder.sourceFile, literal);
+    const resolved = resolveSpecifier(builder.context, specifier, builder.record.abs, mode);
+    if (!resolved) {
+        if (!isBareSpecifier(specifier))
+            builder.facts.unresolved.push({ specifier, line });
+        return null;
+    }
+    const rel = tryNormalizeGraphPath(builder.context.root, resolved.fileName);
+    if (rel === null) {
+        if (!resolved.external && !isBareSpecifier(specifier)) {
+            builder.facts.skips.push({
+                path: builder.facts.rel,
+                reason: 'excluded',
+                detail: `import '${specifier}' resolves outside the workspace`
+            });
+        }
+        return null;
+    }
+    if (!builder.isKnownFile(rel))
+        return null;
+    return rel;
+}
+function noteImport(builder, targetRel, line) {
+    if (builder.importLines.has(targetRel))
+        return;
+    builder.importLines.set(targetRel, line);
+    builder.facts.imports.push({ targetRel, line });
+}
+function collectImportDeclaration(builder, statement) {
+    const specifier = statement.moduleSpecifier;
+    if (!ts.isStringLiteralLike(specifier))
+        return;
+    const line = lineOf(builder.sourceFile, statement);
+    const targetRel = resolveTargetRel(builder, specifier, line);
+    if (targetRel)
+        noteImport(builder, targetRel, line);
+    const clause = statement.importClause;
+    if (!clause)
+        return;
+    const push = (local, exportName) => {
+        builder.facts.bindings.push({ local, exportName, specifier: specifier.text, targetRel, line });
+    };
+    if (clause.name)
+        push(clause.name.text, 'default');
+    const bindings = clause.namedBindings;
+    if (!bindings)
+        return;
+    if (ts.isNamespaceImport(bindings)) {
+        push(bindings.name.text, '*');
+        return;
+    }
+    for (const element of bindings.elements) {
+        push(element.name.text, (element.propertyName ?? element.name).text);
+    }
+}
+function collectImportEquals(builder, statement) {
+    const reference = statement.moduleReference;
+    if (!ts.isExternalModuleReference(reference))
+        return;
+    const specifier = reference.expression;
+    if (!ts.isStringLiteralLike(specifier))
+        return;
+    const line = lineOf(builder.sourceFile, statement);
+    const targetRel = resolveTargetRel(builder, specifier, line);
+    if (targetRel)
+        noteImport(builder, targetRel, line);
+    builder.facts.bindings.push({
+        local: statement.name.text,
+        exportName: 'export=',
+        specifier: specifier.text,
+        targetRel,
+        line
+    });
+}
+function collectExportDeclaration(builder, statement) {
+    const specifier = statement.moduleSpecifier;
+    if (!specifier || !ts.isStringLiteralLike(specifier))
+        return;
+    const line = lineOf(builder.sourceFile, statement);
+    const targetRel = resolveTargetRel(builder, specifier, line);
+    if (!targetRel)
+        return;
+    const clause = statement.exportClause;
+    const record = { targetRel, line, star: !clause, names: [] };
+    if (clause && ts.isNamedExports(clause)) {
+        for (const element of clause.elements) {
+            record.names.push({ exportName: element.name.text, sourceName: (element.propertyName ?? element.name).text });
+        }
+    }
+    builder.facts.reexports.push(record);
+}
+function collectCallSpecifiers(builder) {
+    const visit = (node) => {
+        if (ts.isCallExpression(node)) {
+            const isDynamicImport = node.expression.kind === ts.SyntaxKind.ImportKeyword;
+            const isRequire = ts.isIdentifier(node.expression) && node.expression.text === 'require';
+            if (isDynamicImport || isRequire) {
+                const argument = node.arguments[0];
+                if (argument && ts.isStringLiteralLike(argument)) {
+                    const line = lineOf(builder.sourceFile, node);
+                    const targetRel = resolveTargetRel(builder, argument, line);
+                    if (targetRel)
+                        noteImport(builder, targetRel, line);
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(builder.sourceFile, visit);
+}
+export function collectModuleFacts(context, parsed, isKnownFile) {
+    const facts = {
+        rel: parsed.record.rel,
+        imports: [],
+        reexports: [],
+        bindings: [],
+        skips: [],
+        unresolved: []
+    };
+    const builder = {
+        facts,
+        record: parsed.record,
+        sourceFile: parsed.sourceFile,
+        context,
+        isKnownFile,
+        importLines: new Map()
+    };
+    for (const statement of parsed.sourceFile.statements) {
+        if (ts.isImportDeclaration(statement))
+            collectImportDeclaration(builder, statement);
+        else if (ts.isImportEqualsDeclaration(statement))
+            collectImportEquals(builder, statement);
+        else if (ts.isExportDeclaration(statement))
+            collectExportDeclaration(builder, statement);
+    }
+    collectCallSpecifiers(builder);
+    return facts;
+}
+export function resolveExportedSymbol(tables, rel, exportName, depth = 0, seen = new Set()) {
+    if (depth > MAX_REEXPORT_DEPTH)
+        return null;
+    const key = `${rel}\u0000${exportName}`;
+    if (seen.has(key))
+        return null;
+    seen.add(key);
+    const direct = tables.exportsByRel.get(rel)?.get(exportName);
+    if (direct)
+        return { rel, symbol: direct, viaReexport: depth > 0 };
+    const facts = tables.factsByRel.get(rel);
+    if (!facts)
+        return null;
+    for (const record of facts.reexports) {
+        for (const name of record.names) {
+            if (name.exportName !== exportName)
+                continue;
+            const nested = resolveExportedSymbol(tables, record.targetRel, name.sourceName, depth + 1, seen);
+            if (nested)
+                return { rel: nested.rel, symbol: nested.symbol, viaReexport: true };
+        }
+    }
+    for (const record of facts.reexports) {
+        if (!record.star)
+            continue;
+        const nested = resolveExportedSymbol(tables, record.targetRel, exportName, depth + 1, seen);
+        if (nested)
+            return { rel: nested.rel, symbol: nested.symbol, viaReexport: true };
+    }
+    return null;
+}
+export function starReexportTargets(tables, rel) {
+    const found = new Set();
+    const walk = (current, depth) => {
+        if (depth > MAX_REEXPORT_DEPTH)
+            return;
+        for (const record of tables.factsByRel.get(current)?.reexports ?? []) {
+            if (!record.star)
+                continue;
+            if (record.targetRel === rel || found.has(record.targetRel))
+                continue;
+            found.add(record.targetRel);
+            walk(record.targetRel, depth + 1);
+        }
+    };
+    walk(rel, 0);
+    return [...found].sort();
+}
+export function buildImportAndReexportEdges(sink, tables, byRel, fileNodeIdByRel) {
+    for (const [rel, facts] of tables.factsByRel) {
+        const record = byRel.get(rel);
+        const from = fileNodeIdByRel.get(rel);
+        if (!record || !from)
+            continue;
+        for (const entry of facts.imports) {
+            const to = fileNodeIdByRel.get(entry.targetRel);
+            if (!to)
+                continue;
+            sink.addEdge({ from, to, type: 'imports', confidence: 'exact', path: rel, hash: record.hash, line: entry.line });
+        }
+        for (const reexport of facts.reexports) {
+            const to = fileNodeIdByRel.get(reexport.targetRel);
+            if (to) {
+                sink.addEdge({ from, to, type: 'reexports', confidence: 'exact', path: rel, hash: record.hash, line: reexport.line });
+            }
+            if (reexport.star) {
+                for (const transitive of starReexportTargets(tables, reexport.targetRel)) {
+                    const target = fileNodeIdByRel.get(transitive);
+                    if (!target || target === from)
+                        continue;
+                    sink.addEdge({ from, to: target, type: 'reexports', confidence: 'exact', path: rel, hash: record.hash, line: reexport.line });
+                }
+                continue;
+            }
+            for (const name of reexport.names) {
+                const resolution = resolveExportedSymbol(tables, reexport.targetRel, name.sourceName);
+                if (!resolution)
+                    continue;
+                sink.addEdge({
+                    from,
+                    to: resolution.symbol.nodeId,
+                    type: 'reexports',
+                    confidence: 'exact',
+                    path: rel,
+                    hash: record.hash,
+                    line: reexport.line
+                });
+                const definingFile = fileNodeIdByRel.get(resolution.rel);
+                if (definingFile && definingFile !== from) {
+                    sink.addEdge({
+                        from,
+                        to: definingFile,
+                        type: 'reexports',
+                        confidence: 'exact',
+                        path: rel,
+                        hash: record.hash,
+                        line: reexport.line
+                    });
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,79 @@
+import { contextGraphNodeId } from '../../ids.js';
+const SOURCE_ROOTS = new Set(['src', 'source', 'lib']);
+const SOURCE_ROOT_DEPTH = 3;
+const PLAIN_DEPTH = 2;
+export const ROOT_MODULE_DIR = '.';
+export function moduleDirForPath(relativePath) {
+    const parts = relativePath.split('/');
+    const dirParts = parts.slice(0, -1);
+    if (!dirParts.length)
+        return ROOT_MODULE_DIR;
+    const head = dirParts[0] ?? '';
+    const depth = SOURCE_ROOTS.has(head) ? SOURCE_ROOT_DEPTH : PLAIN_DEPTH;
+    return dirParts.slice(0, Math.min(depth, dirParts.length)).join('/');
+}
+function moduleLabel(dir) {
+    if (dir === ROOT_MODULE_DIR)
+        return 'root';
+    const parts = dir.split('/');
+    const head = parts[0] ?? '';
+    const trimmed = SOURCE_ROOTS.has(head) && parts.length > 1 ? parts.slice(1) : parts;
+    return trimmed.join('-') || dir;
+}
+export function inferModuleBoundaries(relativePaths) {
+    const byDir = new Map();
+    for (const rel of relativePaths) {
+        const dir = moduleDirForPath(rel);
+        const bucket = byDir.get(dir);
+        if (bucket)
+            bucket.push(rel);
+        else
+            byDir.set(dir, [rel]);
+    }
+    const boundaries = [];
+    for (const [dir, files] of byDir) {
+        boundaries.push({
+            moduleId: dir,
+            dir,
+            nodeId: contextGraphNodeId({ kind: 'module', moduleId: dir }),
+            files: files.sort()
+        });
+    }
+    return boundaries.sort((left, right) => (left.dir < right.dir ? -1 : left.dir > right.dir ? 1 : 0));
+}
+function moduleTokenCost(fileCount) {
+    return 8 + fileCount * 2;
+}
+export function buildModuleNodes(sink, boundaries) {
+    for (const boundary of boundaries) {
+        const capPath = boundary.files[0] ?? boundary.dir;
+        sink.addNode({
+            id: boundary.nodeId,
+            kind: 'module',
+            label: moduleLabel(boundary.dir),
+            ...(boundary.dir === ROOT_MODULE_DIR ? {} : { path: boundary.dir }),
+            trust: 0.8,
+            risk: 'low',
+            tokenCost: moduleTokenCost(boundary.files.length),
+            metadata: { dir: boundary.dir, fileCount: boundary.files.length }
+        }, capPath);
+    }
+}
+export function buildModuleContainsEdges(sink, boundaries, fileNodeIdByRel, byRel) {
+    for (const boundary of boundaries) {
+        for (const rel of boundary.files) {
+            const fileNodeId = fileNodeIdByRel.get(rel);
+            const record = byRel.get(rel);
+            if (!fileNodeId || !record)
+                continue;
+            sink.addEdge({
+                from: boundary.nodeId,
+                to: fileNodeId,
+                type: 'contains',
+                confidence: 'exact',
+                path: rel,
+                hash: record.hash
+            });
+        }
+    }
+}