arceus-s 1.6.4

package/dist/core/ingestion/languages/typescript.js

@@ -0,0 +1,324 @@
+/**
+ * TypeScript and JavaScript language providers.
+ *
+ * Both languages share the same type extraction config (typescriptConfig),
+ * export checker (tsExportChecker), and named binding extractor
+ * (extractTsNamedBindings). They differ in file extensions, tree-sitter
+ * queries (TypeScript grammar has interface/type nodes), and language ID.
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { defineLanguage } from '../language-provider.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
+import { typescriptClassConfig, javascriptClassConfig, } from '../class-extractors/configs/typescript-javascript.js';
+import { typeConfig as typescriptConfig } from '../type-extractors/typescript.js';
+import { tsExportChecker } from '../export-detection.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { typescriptImportConfig, javascriptImportConfig, } from '../import-resolvers/configs/typescript-javascript.js';
+import { extractTsNamedBindings } from '../named-bindings/typescript.js';
+import { TYPESCRIPT_QUERIES, JAVASCRIPT_QUERIES } from '../tree-sitter-queries.js';
+import { typescriptFieldExtractor } from '../field-extractors/typescript.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { javascriptConfig } from '../field-extractors/configs/typescript-javascript.js';
+import { createMethodExtractor } from '../method-extractors/generic.js';
+import { typescriptMethodConfig, javascriptMethodConfig, } from '../method-extractors/configs/typescript-javascript.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { typescriptVariableConfig, javascriptVariableConfig, } from '../variable-extractors/configs/typescript-javascript.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { typescriptCallConfig, javascriptCallConfig, } from '../call-extractors/configs/typescript-javascript.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+import { emitTsScopeCaptures, interpretTsImport, interpretTsTypeBinding, tsBindingScopeFor, tsImportOwningScope, tsReceiverBinding, typescriptMergeBindings, typescriptArityCompatibility, resolveTsImportTarget, } from './typescript/index.js';
+/**
+ * TypeScript/JavaScript: arrow_function and function_expression are
+ * anonymous AST nodes — they take their name from the surrounding
+ * declarative context.
+ *
+ * Recognised contexts:
+ *   - `const foo = () => {}` (variable_declarator) → "foo"
+ *   - `{ addItem: (item) => ... }` (pair / property_assignment) → "addItem"
+ *     Covers Zustand stores, TanStack Query factories, React Context
+ *     providers, and most other HOF-heavy idioms (issue #1166).
+ *   - `const X = HOC((args) => { ... })` (arguments → call_expression →
+ *     variable_declarator) → "X". Covers `React.forwardRef`, `memo`,
+ *     `useCallback`, `useMemo`, `observer`, `debounce`, and other HOC
+ *     factories that wrap their behaviour-defining arrow. Without this
+ *     branch, every shadcn/Radix UI component (`const Button =
+ *     React.forwardRef(...)`) registered as an anonymous arrow with
+ *     calls inside falling back to File-level attribution. The same
+ *     applied to all `useCallback` / `useMemo` callbacks bound to a
+ *     const — the sole way to give them a named caller anchor.
+ *
+ * Returns `null` for funcName when the arrow lives in a context that has
+ * no static name — bare call arguments (not bound to a const), computed
+ * keys, return-from-arrow positions. The parent walk in
+ * findEnclosingFunctionId then continues up to the next named ancestor
+ * (or to the file).
+ */
+const tsExtractFunctionName = (node) => {
+    if (node.type !== 'arrow_function' && node.type !== 'function_expression')
+        return null;
+    const parent = node.parent;
+    if (!parent)
+        return null;
+    if (parent.type === 'variable_declarator') {
+        let nameNode = parent.childForFieldName?.('name');
+        if (!nameNode) {
+            for (let i = 0; i < parent.childCount; i++) {
+                const c = parent.child(i);
+                if (c?.type === 'identifier') {
+                    nameNode = c;
+                    break;
+                }
+            }
+        }
+        return { funcName: nameNode?.text ?? null, label: 'Function' };
+    }
+    // Object property pair: `{ addItem: (item) => ... }`.
+    // tree-sitter-typescript uses `pair`; tree-sitter-javascript also exposes
+    // `pair`. (Older grammars used `property_assignment`; we accept both.)
+    if (parent.type === 'pair' || parent.type === 'property_assignment') {
+        const keyNode = parent.childForFieldName?.('key');
+        if (!keyNode)
+            return { funcName: null, label: 'Function' };
+        if (keyNode.type === 'property_identifier' || keyNode.type === 'identifier') {
+            return { funcName: keyNode.text, label: 'Function' };
+        }
+        if (keyNode.type === 'string') {
+            // `"add-item": () => ...` — the literal text inside the quotes.
+            const fragment = keyNode.children?.find((c) => c.type === 'string_fragment');
+            const text = fragment?.text ?? null;
+            return { funcName: text, label: 'Function' };
+        }
+        // computed_property_name (`[ACTION_KEY]`) and other dynamic keys have
+        // no static name — fall through anonymous.
+        return { funcName: null, label: 'Function' };
+    }
+    // HOC-wrapped variable declarations: `const Button = forwardRef((p, r) => { ... })`,
+    // `const handleClick = useCallback(() => doStuff(), [deps])`,
+    // `const Card = React.memo((props) => { ... })`. The arrow's `parent` is
+    // `arguments`, grandparent is `call_expression`, great-grandparent is
+    // `variable_declarator`. Walk the chain up and take the variable's name
+    // — the meaningful identifier the developer wrote on the LHS. Mirrors
+    // the four registry-primary patterns in `typescript/query.ts`. The
+    // wrapping callee (`forwardRef`, `memo`, `React.memo`, `useCallback`,
+    // user-defined HOCs) is intentionally NOT constrained: any function
+    // call whose result is bound to a const and whose first/positional
+    // argument is an arrow takes the const's name. Chained array-method
+    // calls (`const x = arr.find((y) => p(y))`) match too and produce a
+    // mostly-harmless `Function:x` (consumed as a value, never invoked),
+    // accepted as a small false-positive cost vs. the much larger gain of
+    // capturing the React UI-component idiom.
+    if (parent.type === 'arguments') {
+        const callExpr = parent.parent;
+        if (!callExpr || callExpr.type !== 'call_expression') {
+            return { funcName: null, label: 'Function' };
+        }
+        const declarator = callExpr.parent;
+        if (!declarator || declarator.type !== 'variable_declarator') {
+            return { funcName: null, label: 'Function' };
+        }
+        const nameNode = declarator.childForFieldName?.('name');
+        if (nameNode?.type === 'identifier') {
+            return { funcName: nameNode.text, label: 'Function' };
+        }
+        return { funcName: null, label: 'Function' };
+    }
+    return { funcName: null, label: 'Function' };
+};
+export const BUILT_INS = new Set([
+    'console',
+    'log',
+    'warn',
+    'error',
+    'info',
+    'debug',
+    'setTimeout',
+    'setInterval',
+    'clearTimeout',
+    'clearInterval',
+    'parseInt',
+    'parseFloat',
+    'isNaN',
+    'isFinite',
+    'encodeURI',
+    'decodeURI',
+    'encodeURIComponent',
+    'decodeURIComponent',
+    'JSON',
+    'parse',
+    'stringify',
+    'Object',
+    'Array',
+    'String',
+    'Number',
+    'Boolean',
+    'Symbol',
+    'BigInt',
+    'Map',
+    'Set',
+    'WeakMap',
+    'WeakSet',
+    'Promise',
+    'resolve',
+    'reject',
+    'then',
+    'catch',
+    'finally',
+    'Math',
+    'Date',
+    'RegExp',
+    'Error',
+    'require',
+    'import',
+    'export',
+    'fetch',
+    'Response',
+    'Request',
+    'useState',
+    'useEffect',
+    'useCallback',
+    'useMemo',
+    'useRef',
+    'useContext',
+    'useReducer',
+    'useLayoutEffect',
+    'useImperativeHandle',
+    'useDebugValue',
+    'createElement',
+    'createContext',
+    'createRef',
+    'forwardRef',
+    'memo',
+    'lazy',
+    'map',
+    'filter',
+    'reduce',
+    'forEach',
+    'find',
+    'findIndex',
+    'some',
+    'every',
+    'includes',
+    'indexOf',
+    'slice',
+    'splice',
+    'concat',
+    'join',
+    'split',
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'sort',
+    'reverse',
+    'keys',
+    'values',
+    'entries',
+    'assign',
+    'freeze',
+    'seal',
+    'hasOwnProperty',
+    'toString',
+    'valueOf',
+]);
+export const typescriptProvider = defineLanguage({
+    id: SupportedLanguages.TypeScript,
+    extensions: ['.ts', '.tsx'],
+    entryPointPatterns: [/^use[A-Z]/],
+    astFrameworkPatterns: [
+        {
+            framework: 'nestjs',
+            entryPointMultiplier: 3.2,
+            reason: 'nestjs-decorator',
+            patterns: ['@Controller', '@Get', '@Post', '@Put', '@Delete', '@Patch'],
+        },
+        {
+            framework: 'expo-router',
+            entryPointMultiplier: 2.5,
+            reason: 'expo-router-navigation',
+            patterns: [
+                'router.push',
+                'router.replace',
+                'router.navigate',
+                'useRouter',
+                'useLocalSearchParams',
+                'useSegments',
+                'expo-router',
+            ],
+        },
+    ],
+    treeSitterQueries: TYPESCRIPT_QUERIES,
+    typeConfig: typescriptConfig,
+    exportChecker: tsExportChecker,
+    importResolver: createImportResolver(typescriptImportConfig),
+    namedBindingExtractor: extractTsNamedBindings,
+    callExtractor: createCallExtractor(typescriptCallConfig),
+    fieldExtractor: typescriptFieldExtractor,
+    methodExtractor: createMethodExtractor({
+        ...typescriptMethodConfig,
+        extractFunctionName: tsExtractFunctionName,
+    }),
+    variableExtractor: createVariableExtractor(typescriptVariableConfig),
+    classExtractor: createClassExtractor(typescriptClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.TypeScript),
+    builtInNames: BUILT_INS,
+    // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
+    // TypeScript is the third migration after Python and C#. See
+    // ./typescript/index.ts for the full per-hook rationale and the
+    // canonical capture vocabulary in ./typescript/query.ts
+    // (TYPESCRIPT_SCOPE_QUERY constant).
+    emitScopeCaptures: emitTsScopeCaptures,
+    interpretImport: interpretTsImport,
+    interpretTypeBinding: interpretTsTypeBinding,
+    bindingScopeFor: tsBindingScopeFor,
+    importOwningScope: tsImportOwningScope,
+    // Merge precedence is decided from BindingRef origin + declaration
+    // space only. The central finalizer already calls this per (scope,
+    // name), so the Scope object itself intentionally does not affect
+    // TypeScript declaration merging.
+    mergeBindings: (_scope, bindings) => typescriptMergeBindings(bindings),
+    receiverBinding: tsReceiverBinding,
+    arityCompatibility: typescriptArityCompatibility,
+    resolveImportTarget: resolveTsImportTarget,
+});
+export const javascriptProvider = defineLanguage({
+    id: SupportedLanguages.JavaScript,
+    extensions: ['.js', '.jsx'],
+    entryPointPatterns: [/^use[A-Z]/],
+    astFrameworkPatterns: [
+        {
+            framework: 'nestjs',
+            entryPointMultiplier: 3.2,
+            reason: 'nestjs-decorator',
+            patterns: ['@Controller', '@Get', '@Post', '@Put', '@Delete', '@Patch'],
+        },
+        {
+            framework: 'expo-router',
+            entryPointMultiplier: 2.5,
+            reason: 'expo-router-navigation',
+            patterns: [
+                'router.push',
+                'router.replace',
+                'router.navigate',
+                'useRouter',
+                'useLocalSearchParams',
+                'useSegments',
+                'expo-router',
+            ],
+        },
+    ],
+    treeSitterQueries: JAVASCRIPT_QUERIES,
+    typeConfig: typescriptConfig,
+    exportChecker: tsExportChecker,
+    importResolver: createImportResolver(javascriptImportConfig),
+    namedBindingExtractor: extractTsNamedBindings,
+    callExtractor: createCallExtractor(javascriptCallConfig),
+    fieldExtractor: createFieldExtractor(javascriptConfig),
+    methodExtractor: createMethodExtractor({
+        ...javascriptMethodConfig,
+        extractFunctionName: tsExtractFunctionName,
+    }),
+    variableExtractor: createVariableExtractor(javascriptVariableConfig),
+    classExtractor: createClassExtractor(javascriptClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.JavaScript),
+    builtInNames: BUILT_INS,
+});

package/dist/core/ingestion/languages/vue.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Vue language provider.
+ *
+ * Vue SFCs are preprocessed by extracting the <script> / <script setup>
+ * block content, which is then parsed as TypeScript. This provider reuses
+ * nearly all TypeScript infrastructure — queries, type config, field
+ * extraction, and named binding extraction.
+ *
+ * Export detection for <script setup> is handled directly in the parse
+ * worker (all top-level bindings are implicitly exported). The export
+ * checker here is used as fallback for non-setup <script> blocks.
+ */
+export declare const vueProvider: import("../language-provider.js").LanguageProvider;

package/dist/core/ingestion/languages/vue.js

@@ -0,0 +1,79 @@
+/**
+ * Vue language provider.
+ *
+ * Vue SFCs are preprocessed by extracting the <script> / <script setup>
+ * block content, which is then parsed as TypeScript. This provider reuses
+ * nearly all TypeScript infrastructure — queries, type config, field
+ * extraction, and named binding extraction.
+ *
+ * Export detection for <script setup> is handled directly in the parse
+ * worker (all top-level bindings are implicitly exported). The export
+ * checker here is used as fallback for non-setup <script> blocks.
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
+import { vueClassConfig } from '../class-extractors/configs/typescript-javascript.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as typescriptConfig } from '../type-extractors/typescript.js';
+import { tsExportChecker } from '../export-detection.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { vueImportConfig } from '../import-resolvers/configs/typescript-javascript.js';
+import { extractTsNamedBindings } from '../named-bindings/typescript.js';
+import { TYPESCRIPT_QUERIES } from '../tree-sitter-queries.js';
+import { typescriptFieldExtractor } from '../field-extractors/typescript.js';
+import { BUILT_INS as TS_BUILT_INS } from './typescript.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { typescriptVariableConfig } from '../variable-extractors/configs/typescript-javascript.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { typescriptCallConfig } from '../call-extractors/configs/typescript-javascript.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+const VUE_SPECIFIC_BUILT_INS = [
+    'ref',
+    'reactive',
+    'computed',
+    'watch',
+    'watchEffect',
+    'onMounted',
+    'onUnmounted',
+    'onBeforeMount',
+    'onBeforeUnmount',
+    'onUpdated',
+    'onBeforeUpdate',
+    'nextTick',
+    'defineProps',
+    'defineEmits',
+    'defineExpose',
+    'defineOptions',
+    'defineSlots',
+    'defineModel',
+    'withDefaults',
+    'toRef',
+    'toRefs',
+    'unref',
+    'isRef',
+    'shallowRef',
+    'triggerRef',
+    'provide',
+    'inject',
+    'useSlots',
+    'useAttrs',
+];
+const VUE_BUILT_INS = new Set([...TS_BUILT_INS, ...VUE_SPECIFIC_BUILT_INS]);
+const vueClassExtractor = createClassExtractor(vueClassConfig);
+export const vueProvider = defineLanguage({
+    id: SupportedLanguages.Vue,
+    extensions: ['.vue'],
+    entryPointPatterns: [],
+    astFrameworkPatterns: [],
+    treeSitterQueries: TYPESCRIPT_QUERIES,
+    typeConfig: typescriptConfig,
+    exportChecker: tsExportChecker,
+    importResolver: createImportResolver(vueImportConfig),
+    namedBindingExtractor: extractTsNamedBindings,
+    callExtractor: createCallExtractor(typescriptCallConfig),
+    fieldExtractor: typescriptFieldExtractor,
+    variableExtractor: createVariableExtractor(typescriptVariableConfig),
+    classExtractor: vueClassExtractor,
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.TypeScript),
+    builtInNames: VUE_BUILT_INS,
+});

package/dist/core/ingestion/markdown-processor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Markdown Processor
+ *
+ * Extracts structure from .md files using regex (no tree-sitter dependency).
+ * Creates Section nodes for headings with hierarchy, and IMPORTS edges for
+ * cross-file links.
+ */
+import { KnowledgeGraph } from '../graph/types.js';
+interface MdFile {
+    path: string;
+    content: string;
+}
+export declare const processMarkdown: (graph: KnowledgeGraph, files: MdFile[], allPathSet: ReadonlySet<string>) => {
+    sections: number;
+    links: number;
+};
+export {};

package/dist/core/ingestion/markdown-processor.js

@@ -0,0 +1,124 @@
+/**
+ * Markdown Processor
+ *
+ * Extracts structure from .md files using regex (no tree-sitter dependency).
+ * Creates Section nodes for headings with hierarchy, and IMPORTS edges for
+ * cross-file links.
+ */
+import path from 'node:path';
+import { generateId } from '../../lib/utils.js';
+const HEADING_RE = /^(#{1,6})\s+(.+)$/;
+const LINK_RE = /\[([^\]]*)\]\(([^)]+)\)/g;
+const MD_EXTENSIONS = new Set(['.md', '.mdx']);
+export const processMarkdown = (graph, files, allPathSet) => {
+    let totalSections = 0;
+    let totalLinks = 0;
+    for (const file of files) {
+        const ext = path.extname(file.path).toLowerCase();
+        if (!MD_EXTENSIONS.has(ext))
+            continue;
+        const fileNodeId = generateId('File', file.path);
+        // Skip if file node doesn't exist (shouldn't happen, structure-processor creates it)
+        if (!graph.getNode(fileNodeId))
+            continue;
+        const lines = file.content.split('\n');
+        // --- Extract headings and build hierarchy ---
+        // First pass: collect all heading positions so we can compute endLine spans
+        const headings = [];
+        for (let i = 0; i < lines.length; i++) {
+            const match = lines[i].match(HEADING_RE);
+            if (!match)
+                continue;
+            headings.push({
+                level: match[1].length,
+                heading: match[2].trim(),
+                lineNum: i + 1, // 1-indexed
+            });
+        }
+        // Second pass: create nodes with proper endLine spans
+        const sectionStack = [];
+        for (let h = 0; h < headings.length; h++) {
+            const { level, heading, lineNum } = headings[h];
+            // endLine = line before next heading at same or higher level, or EOF
+            let endLine = lines.length;
+            for (let j = h + 1; j < headings.length; j++) {
+                if (headings[j].level <= level) {
+                    endLine = headings[j].lineNum - 1;
+                    break;
+                }
+            }
+            const sectionId = generateId('Section', `${file.path}:L${lineNum}:${heading}`);
+            const node = {
+                id: sectionId,
+                label: 'Section',
+                properties: {
+                    name: heading,
+                    filePath: file.path,
+                    startLine: lineNum,
+                    endLine,
+                    level,
+                    description: `h${level}`,
+                },
+            };
+            graph.addNode(node);
+            totalSections++;
+            // Find parent: pop stack until we find a level strictly less than current
+            while (sectionStack.length > 0 && sectionStack[sectionStack.length - 1].level >= level) {
+                sectionStack.pop();
+            }
+            const parentId = sectionStack.length > 0 ? sectionStack[sectionStack.length - 1].id : fileNodeId;
+            graph.addRelationship({
+                id: generateId('CONTAINS', `${parentId}->${sectionId}`),
+                type: 'CONTAINS',
+                sourceId: parentId,
+                targetId: sectionId,
+                confidence: 1.0,
+                reason: 'markdown-heading',
+            });
+            sectionStack.push({ level, id: sectionId });
+        }
+        // --- Extract links to other files in the repo ---
+        const fileDir = path.dirname(file.path);
+        const seenLinks = new Set();
+        let linkMatch;
+        LINK_RE.lastIndex = 0;
+        while ((linkMatch = LINK_RE.exec(file.content)) !== null) {
+            const href = linkMatch[2];
+            // Skip external URLs, anchors, and mailto
+            if (href.startsWith('http://') ||
+                href.startsWith('https://') ||
+                href.startsWith('#') ||
+                href.startsWith('mailto:')) {
+                continue;
+            }
+            // Strip anchor fragments from local links
+            const cleanHref = href.split('#')[0];
+            if (!cleanHref)
+                continue;
+            // Resolve relative to the file's directory, then normalize
+            const resolved = path.posix.normalize(path.posix.join(fileDir, cleanHref));
+            if (allPathSet.has(resolved)) {
+                const targetFileId = generateId('File', resolved);
+                // Skip if target file node doesn't exist
+                if (!graph.getNode(targetFileId))
+                    continue;
+                // Dedup: skip if we've already linked this file pair
+                const linkKey = `${fileNodeId}->${targetFileId}`;
+                if (seenLinks.has(linkKey))
+                    continue;
+                seenLinks.add(linkKey);
+                const relId = generateId('IMPORTS', linkKey);
+                graph.addRelationship({
+                    id: relId,
+                    type: 'IMPORTS',
+                    sourceId: fileNodeId,
+                    targetId: targetFileId,
+                    confidence: 0.8,
+                    reason: 'markdown-link',
+                });
+                totalLinks++;
+            }
+        }
+    }
+    return { sections: totalSections, links: totalLinks };
+};

package/dist/core/ingestion/method-extractors/configs/c-cpp.d.ts

@@ -0,0 +1,3 @@
+import type { MethodExtractionConfig } from '../../method-types.js';
+export declare const cppMethodConfig: MethodExtractionConfig;
+export declare const cMethodConfig: MethodExtractionConfig;