@kentwynn/kgraph 0.1.20 → 0.1.21

package/README.md

@@ -51,6 +51,7 @@ KGraph stores the reusable parts locally:
 - What files exist and what language they use.
 - What symbols each source file defines.
 - Which files import each other.
+- Which TypeScript/JavaScript functions and methods directly call each other when KGraph can infer it cheaply.
 - Which notes, decisions, debugging findings, and gotchas were captured from prior sessions.
 - Which cognition references are current, mixed, stale, or unresolved after code moves.
 
@@ -240,7 +241,7 @@ The files are local, inspectable, and human-readable. There is no database, tele
 
 KGraph deeply scans:
 
-- TypeScript and JavaScript
+- TypeScript and JavaScript, including lightweight function/method call relationships
 - Python
 - Go
 - Rust
@@ -248,7 +249,7 @@ KGraph deeply scans:
 - C and C++
 - C#
 
-Other common file types still appear in the file map with generic metadata, so context queries can still point to docs, config, SQL, CSS, HTML, YAML, and similar files.
+Other languages keep practical file, import, and symbol depth without full call graph analysis. Common file types still appear in the file map with generic metadata, so context queries can still point to docs, config, SQL, CSS, HTML, YAML, and similar files.
 
 ## Visualization
 
@@ -256,7 +257,7 @@ Other common file types still appear in the file map with generic metadata, so c
 kgraph visualize
 ```
 
-The graph shows files, symbols, imports, cognition notes, and relationship edges. Cognition notes are colored by reference health:
+The graph shows files, symbols, imports, TypeScript/JavaScript call edges, ownership edges, cognition notes, and relationship edges. Cognition notes are colored by reference health:
 
 - current
 - mixed

package/dist/context/context-query.js

@@ -39,6 +39,13 @@ export async function queryContext(workspace, config, maps, query) {
             ...domain.item.symbols,
         ]),
     ]);
+    for (const relationship of maps.relationshipMap.relationships) {
+        if (relatedIds.has(relationship.sourceId) ||
+            relatedIds.has(relationship.targetId)) {
+            relatedIds.add(relationship.sourceId);
+            relatedIds.add(relationship.targetId);
+        }
+    }
     const rankedRelationships = rankByFields(query, maps.relationshipMap.relationships, [
         { name: 'source', value: (relationship) => relationship.sourceId },
         { name: 'target', value: (relationship) => relationship.targetId },

package/dist/scanner/ts-symbol-extractor.js

@@ -6,11 +6,14 @@ export function extractTsSymbols(sourceText, filePath) {
     const dependencies = [];
     const relationships = [];
     const warnings = [];
+    const symbolIdsByNode = new Map();
+    const symbolsByName = new Map();
+    const importedBindings = new Map();
     const addSymbol = (name, kind, node, exported = false, parentName) => {
         const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
         const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
         const id = [filePath, kind, parentName, name, start.line + 1, end.line + 1].filter(Boolean).join("#");
-        symbols.push({
+        const symbol = {
             id,
             name,
             kind,
@@ -19,7 +22,12 @@ export function extractTsSymbols(sourceText, filePath) {
             endLine: end.line + 1,
             exported,
             parentName
-        });
+        };
+        symbols.push(symbol);
+        symbolIdsByNode.set(node, id);
+        const byName = symbolsByName.get(name) ?? [];
+        byName.push(symbol);
+        symbolsByName.set(name, byName);
         relationships.push({
             sourceType: "file",
             sourceId: filePath,
@@ -28,8 +36,9 @@ export function extractTsSymbols(sourceText, filePath) {
             relationshipType: "contains",
             confidence: "high"
         });
+        return symbol;
     };
-    const visit = (node, parentName) => {
+    const collectSymbols = (node, parentName) => {
         if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
             const specifier = node.moduleSpecifier.text;
             const dependency = {
@@ -48,6 +57,7 @@ export function extractTsSymbols(sourceText, filePath) {
                 relationshipType: "import",
                 confidence: dependency.resolvedFile ? "high" : "medium"
             });
+            collectImportedBindings(node, specifier, dependency.resolvedFile, importedBindings);
         }
         if (ts.isExportDeclaration(node)) {
             const name = node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : "export";
@@ -66,10 +76,18 @@ export function extractTsSymbols(sourceText, filePath) {
             }
         }
         if (ts.isClassDeclaration(node) && node.name) {
-            addSymbol(node.name.text, "class", node, isExported(node), parentName);
+            const classSymbol = addSymbol(node.name.text, "class", node, isExported(node), parentName);
             node.members.forEach((member) => {
                 if (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name)) {
-                    addSymbol(member.name.text, "method", member, false, node.name?.text);
+                    const methodSymbol = addSymbol(member.name.text, "method", member, false, node.name?.text);
+                    relationships.push({
+                        sourceType: "symbol",
+                        sourceId: classSymbol.id,
+                        targetType: "symbol",
+                        targetId: methodSymbol.id,
+                        relationshipType: "symbol-contains",
+                        confidence: "high"
+                    });
                 }
             });
         }
@@ -79,16 +97,85 @@ export function extractTsSymbols(sourceText, filePath) {
         if (ts.isTypeAliasDeclaration(node)) {
             addSymbol(node.name.text, "type", node, isExported(node), parentName);
         }
-        ts.forEachChild(node, (child) => visit(child, parentName));
+        ts.forEachChild(node, (child) => collectSymbols(child, parentName));
+    };
+    const collectCalls = (node, currentSymbolId) => {
+        const nextSymbolId = symbolIdsByNode.get(node) ?? currentSymbolId;
+        if (ts.isCallExpression(node) && nextSymbolId) {
+            const target = resolveCallTarget(node, symbolsByName, importedBindings);
+            if (target) {
+                relationships.push({
+                    sourceType: "symbol",
+                    sourceId: nextSymbolId,
+                    targetType: target.targetType,
+                    targetId: target.targetId,
+                    relationshipType: "calls",
+                    confidence: target.confidence
+                });
+            }
+        }
+        ts.forEachChild(node, (child) => collectCalls(child, nextSymbolId));
     };
     try {
-        visit(sourceFile);
+        collectSymbols(sourceFile);
+        collectCalls(sourceFile);
     }
     catch (error) {
         warnings.push(error instanceof Error ? error.message : String(error));
     }
     return { symbols, dependencies, relationships, warnings };
 }
+function collectImportedBindings(node, specifier, resolvedFile, importedBindings) {
+    const clause = node.importClause;
+    if (!clause) {
+        return;
+    }
+    if (clause.name) {
+        importedBindings.set(clause.name.text, { specifier, resolvedFile });
+    }
+    const bindings = clause.namedBindings;
+    if (bindings && ts.isNamedImports(bindings)) {
+        for (const element of bindings.elements) {
+            importedBindings.set(element.name.text, { specifier, resolvedFile });
+        }
+    }
+}
+function resolveCallTarget(node, symbolsByName, importedBindings) {
+    const expression = node.expression;
+    if (ts.isIdentifier(expression)) {
+        const localSymbols = symbolsByName
+            .get(expression.text)
+            ?.filter((symbol) => symbol.kind === "function" || symbol.kind === "method");
+        if (localSymbols?.[0]) {
+            return {
+                targetType: "symbol",
+                targetId: localSymbols[0].id,
+                confidence: "high"
+            };
+        }
+        const imported = importedBindings.get(expression.text);
+        if (imported) {
+            return {
+                targetType: "symbol",
+                targetId: imported.resolvedFile ? `${imported.resolvedFile}#${expression.text}` : expression.text,
+                confidence: imported.resolvedFile ? "medium" : "low"
+            };
+        }
+        return {
+            targetType: "symbol",
+            targetId: expression.text,
+            confidence: "low"
+        };
+    }
+    if (ts.isPropertyAccessExpression(expression)) {
+        return {
+            targetType: "symbol",
+            targetId: expression.getText(),
+            confidence: "low"
+        };
+    }
+    return undefined;
+}
 function isExported(node) {
     return ts.canHaveModifiers(node) && Boolean(ts.getModifiers(node)?.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword));
 }

package/dist/types/maps.d.ts

@@ -1,7 +1,7 @@
 export type ScanStatus = "mapped" | "generic" | "failed";
 export type DependencyKind = "local" | "package" | "unknown";
 export type SymbolKind = "function" | "class" | "method" | "type" | "interface" | "export" | "import";
-export type RelationshipType = "import" | "contains" | "mentions" | "belongs-to-domain" | "stale-reference" | "moved-from";
+export type RelationshipType = "import" | "contains" | "symbol-contains" | "calls" | "mentions" | "belongs-to-domain" | "stale-reference" | "moved-from";
 export interface RepositoryFile {
     id: string;
     path: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kentwynn/kgraph",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "description": "Persistent repo intelligence for AI coding assistants.",
   "type": "module",
   "bin": {