@kentwynn/kgraph 0.1.0

package/dist/context/context-query.js

@@ -0,0 +1,42 @@
+import { readCognitionNotes, readDomainRecords } from "../storage/cognition-store.js";
+import { rankByFields } from "./ranking.js";
+export async function queryContext(workspace, config, maps, query) {
+    const cognition = await readCognitionNotes(workspace);
+    const domains = await readDomainRecords(workspace);
+    const max = config.maxContextItems;
+    const relevantFiles = rankByFields(query, maps.fileMap.files, [
+        { name: "path", value: (file) => file.path },
+        { name: "language", value: (file) => file.language }
+    ]).slice(0, max);
+    const relevantSymbols = rankByFields(query, maps.symbolMap.symbols, [
+        { name: "name", value: (symbol) => symbol.name },
+        { name: "path", value: (symbol) => symbol.filePath },
+        { name: "kind", value: (symbol) => symbol.kind }
+    ]).slice(0, max);
+    const relevantCognition = rankByFields(query, cognition, [
+        { name: "title", value: (note) => note.title },
+        { name: "domain", value: (note) => note.domain },
+        { name: "tags", value: (note) => note.tags },
+        { name: "files", value: (note) => note.relatedFiles },
+        { name: "symbols", value: (note) => note.relatedSymbols },
+        { name: "summary", value: (note) => note.summary }
+    ]).slice(0, max);
+    const matchedDomains = rankByFields(query, domains, [
+        { name: "name", value: (domain) => domain.name },
+        { name: "tags", value: (domain) => domain.tags },
+        { name: "path", value: (domain) => domain.pathHints }
+    ]).slice(0, max);
+    const staleReferences = cognition
+        .filter((note) => note.referencesStatus === "stale" || note.referencesStatus === "unresolved" || note.referencesStatus === "mixed")
+        .flatMap((note) => [...note.relatedFiles, ...note.relatedSymbols].map((ref) => `${note.title}: ${ref}`));
+    return {
+        query,
+        matchedDomains,
+        relevantFiles,
+        relevantSymbols,
+        relevantCognition,
+        relationships: maps.relationshipMap.relationships.slice(0, max),
+        staleReferences,
+        warnings: []
+    };
+}

package/dist/context/ranking.d.ts

@@ -0,0 +1,10 @@
+export interface Ranked<T> {
+    item: T;
+    score: number;
+    reasons: string[];
+}
+export declare function tokenize(query: string): string[];
+export declare function rankByFields<T>(query: string, items: T[], fields: Array<{
+    name: string;
+    value: (item: T) => string | string[] | undefined;
+}>): Ranked<T>[];

package/dist/context/ranking.js

@@ -0,0 +1,29 @@
+export function tokenize(query) {
+    return query
+        .toLowerCase()
+        .split(/[^a-z0-9_$./-]+/)
+        .map((token) => token.trim())
+        .filter(Boolean);
+}
+export function rankByFields(query, items, fields) {
+    const tokens = tokenize(query);
+    return items
+        .map((item) => {
+        let score = 0;
+        const reasons = [];
+        for (const field of fields) {
+            const value = field.value(item);
+            const values = Array.isArray(value) ? value : value ? [value] : [];
+            const haystack = values.join(" ").toLowerCase();
+            for (const token of tokens) {
+                if (haystack.includes(token)) {
+                    score += field.name === "path" || field.name === "name" ? 3 : 1;
+                    reasons.push(`${field.name} matched "${token}"`);
+                }
+            }
+        }
+        return { item, score, reasons };
+    })
+        .filter((ranked) => ranked.score > 0)
+        .sort((a, b) => b.score - a.score);
+}

package/dist/scanner/file-classifier.d.ts

@@ -0,0 +1,4 @@
+import type { KGraphConfig } from "../types/config.js";
+export declare function shouldExclude(repoPath: string, config: KGraphConfig): boolean;
+export declare function detectLanguage(filePath: string): string;
+export declare function isPreciseLanguage(filePath: string, config: KGraphConfig): boolean;

package/dist/scanner/file-classifier.js

@@ -0,0 +1,24 @@
+import path from "node:path";
+const LANGUAGE_BY_EXTENSION = {
+    ".js": "javascript",
+    ".jsx": "javascriptreact",
+    ".ts": "typescript",
+    ".tsx": "typescriptreact",
+    ".json": "json",
+    ".md": "markdown",
+    ".yaml": "yaml",
+    ".yml": "yaml"
+};
+export function shouldExclude(repoPath, config) {
+    const parts = repoPath.split(/[\\/]/);
+    return config.exclude.some((pattern) => {
+        const normalized = pattern.replace(/\/$/, "");
+        return parts.includes(normalized) || repoPath === normalized || repoPath.startsWith(`${normalized}/`);
+    });
+}
+export function detectLanguage(filePath) {
+    return LANGUAGE_BY_EXTENSION[path.extname(filePath)] ?? "unknown";
+}
+export function isPreciseLanguage(filePath, config) {
+    return config.languages.precise.includes(path.extname(filePath));
+}

package/dist/scanner/repo-scanner.d.ts

@@ -0,0 +1,3 @@
+import type { KGraphConfig } from "../types/config.js";
+import type { ScanResult } from "../types/maps.js";
+export declare function scanRepository(rootPath: string, config: KGraphConfig, previous?: ScanResult): Promise<ScanResult>;

package/dist/scanner/repo-scanner.js

@@ -0,0 +1,85 @@
+import { readFile, stat } from "node:fs/promises";
+import crypto from "node:crypto";
+import path from "node:path";
+import fg from "fast-glob";
+import { detectLanguage, isPreciseLanguage, shouldExclude } from "./file-classifier.js";
+import { extractTsSymbols } from "./ts-symbol-extractor.js";
+export async function scanRepository(rootPath, config, previous) {
+    const entries = await fg(config.include, {
+        cwd: rootPath,
+        dot: true,
+        onlyFiles: true,
+        unique: true,
+        ignore: config.exclude.map((item) => `**/${item}/**`)
+    });
+    const files = [];
+    const symbols = [];
+    const dependencies = [];
+    const relationships = [];
+    const warnings = [];
+    for (const repoPath of entries.sort()) {
+        if (shouldExclude(repoPath, config)) {
+            continue;
+        }
+        const absolutePath = path.join(rootPath, repoPath);
+        try {
+            const [info, content] = await Promise.all([stat(absolutePath), readFile(absolutePath)]);
+            const text = content.toString("utf8");
+            const contentHash = crypto.createHash("sha256").update(content).digest("hex");
+            const file = {
+                id: repoPath,
+                path: repoPath,
+                extension: path.extname(repoPath),
+                language: detectLanguage(repoPath),
+                sizeBytes: info.size,
+                modifiedAt: info.mtime.toISOString(),
+                contentHash,
+                scanStatus: isPreciseLanguage(repoPath, config) ? "mapped" : "generic",
+                warnings: []
+            };
+            if (isPreciseLanguage(repoPath, config)) {
+                const extracted = extractTsSymbols(text, repoPath);
+                symbols.push(...extracted.symbols);
+                dependencies.push(...extracted.dependencies);
+                relationships.push(...extracted.relationships);
+                file.warnings.push(...extracted.warnings);
+            }
+            files.push(file);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push(`${repoPath}: ${message}`);
+            files.push({
+                id: repoPath,
+                path: repoPath,
+                extension: path.extname(repoPath),
+                language: detectLanguage(repoPath),
+                sizeBytes: 0,
+                contentHash: "",
+                scanStatus: "failed",
+                warnings: [message]
+            });
+        }
+    }
+    relationships.push(...detectMovedFiles(previous?.files ?? [], files));
+    return { files, symbols, dependencies, relationships, warnings };
+}
+function detectMovedFiles(previousFiles, currentFiles) {
+    const currentPaths = new Set(currentFiles.map((file) => file.path));
+    const previousByHash = new Map(previousFiles.filter((file) => file.contentHash).map((file) => [file.contentHash, file]));
+    const relationships = [];
+    for (const file of currentFiles) {
+        const previous = previousByHash.get(file.contentHash);
+        if (previous && previous.path !== file.path && !currentPaths.has(previous.path)) {
+            relationships.push({
+                sourceType: "file",
+                sourceId: file.path,
+                targetType: "file",
+                targetId: previous.path,
+                relationshipType: "moved-from",
+                confidence: "high"
+            });
+        }
+    }
+    return relationships;
+}

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

@@ -0,0 +1,8 @@
+import type { CodeSymbol, Dependency, Relationship } from "../types/maps.js";
+export interface SymbolExtractionResult {
+    symbols: CodeSymbol[];
+    dependencies: Dependency[];
+    relationships: Relationship[];
+    warnings: string[];
+}
+export declare function extractTsSymbols(sourceText: string, filePath: string): SymbolExtractionResult;

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

@@ -0,0 +1,99 @@
+import path from "node:path";
+import ts from "typescript";
+export function extractTsSymbols(sourceText, filePath) {
+    const sourceFile = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true);
+    const symbols = [];
+    const dependencies = [];
+    const relationships = [];
+    const warnings = [];
+    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({
+            id,
+            name,
+            kind,
+            filePath,
+            startLine: start.line + 1,
+            endLine: end.line + 1,
+            exported,
+            parentName
+        });
+        relationships.push({
+            sourceType: "file",
+            sourceId: filePath,
+            targetType: "symbol",
+            targetId: id,
+            relationshipType: "contains",
+            confidence: "high"
+        });
+    };
+    const visit = (node, parentName) => {
+        if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+            const specifier = node.moduleSpecifier.text;
+            const dependency = {
+                fromFile: filePath,
+                specifier,
+                resolvedFile: resolveLocalImport(filePath, specifier),
+                kind: specifier.startsWith(".") ? "local" : "package"
+            };
+            dependencies.push(dependency);
+            addSymbol(specifier, "import", node);
+            relationships.push({
+                sourceType: "file",
+                sourceId: filePath,
+                targetType: dependency.kind === "local" ? "file" : "package",
+                targetId: dependency.resolvedFile ?? specifier,
+                relationshipType: "import",
+                confidence: dependency.resolvedFile ? "high" : "medium"
+            });
+        }
+        if (ts.isExportDeclaration(node)) {
+            const name = node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : "export";
+            addSymbol(name, "export", node, true);
+        }
+        if (ts.isFunctionDeclaration(node) && node.name) {
+            addSymbol(node.name.text, "function", node, isExported(node), parentName);
+        }
+        if (ts.isVariableStatement(node)) {
+            for (const declaration of node.declarationList.declarations) {
+                if (ts.isIdentifier(declaration.name) &&
+                    declaration.initializer &&
+                    (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))) {
+                    addSymbol(declaration.name.text, "function", declaration, isExported(node), parentName);
+                }
+            }
+        }
+        if (ts.isClassDeclaration(node) && node.name) {
+            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);
+                }
+            });
+        }
+        ts.forEachChild(node, (child) => visit(child, parentName));
+    };
+    try {
+        visit(sourceFile);
+    }
+    catch (error) {
+        warnings.push(error instanceof Error ? error.message : String(error));
+    }
+    return { symbols, dependencies, relationships, warnings };
+}
+function isExported(node) {
+    return ts.canHaveModifiers(node) && Boolean(ts.getModifiers(node)?.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword));
+}
+function resolveLocalImport(fromFile, specifier) {
+    if (!specifier.startsWith(".")) {
+        return undefined;
+    }
+    const joined = path.posix.normalize(path.posix.join(path.posix.dirname(fromFile), specifier));
+    const ext = path.posix.extname(joined);
+    if (ext) {
+        return joined;
+    }
+    return `${joined}.ts`;
+}

package/dist/storage/cognition-store.d.ts

@@ -0,0 +1,9 @@
+import type { KGraphWorkspace } from "../types/config.js";
+import type { CognitionNote, DomainRecord } from "../types/cognition.js";
+export declare function listInboxNotes(workspace: KGraphWorkspace): Promise<string[]>;
+export declare function archiveInboxNote(workspace: KGraphWorkspace, inboxPath: string, timestamp: string): Promise<string>;
+export declare function writeCognitionNote(workspace: KGraphWorkspace, note: CognitionNote): Promise<string>;
+export declare function writeDomainRecord(workspace: KGraphWorkspace, domain: DomainRecord): Promise<string>;
+export declare function readCognitionNotes(workspace: KGraphWorkspace): Promise<CognitionNote[]>;
+export declare function readDomainRecords(workspace: KGraphWorkspace): Promise<DomainRecord[]>;
+export declare function slugify(value: string): string;

package/dist/storage/cognition-store.js

@@ -0,0 +1,90 @@
+import { mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { pathExists } from "./kgraph-paths.js";
+export async function listInboxNotes(workspace) {
+    if (!(await pathExists(workspace.inboxPath))) {
+        return [];
+    }
+    const entries = await readdir(workspace.inboxPath, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".md"))
+        .map((entry) => path.join(workspace.inboxPath, entry.name))
+        .sort();
+}
+export async function archiveInboxNote(workspace, inboxPath, timestamp) {
+    await mkdir(workspace.processedInteractionsPath, { recursive: true });
+    const target = path.join(workspace.processedInteractionsPath, `${timestamp}-${path.basename(inboxPath)}`);
+    await rename(inboxPath, target);
+    return target;
+}
+export async function writeCognitionNote(workspace, note) {
+    await mkdir(workspace.cognitionPath, { recursive: true });
+    const filePath = path.join(workspace.cognitionPath, `${note.id}.md`);
+    await writeFile(filePath, renderCognitionNote(note), "utf8");
+    return filePath;
+}
+export async function writeDomainRecord(workspace, domain) {
+    await mkdir(workspace.domainsPath, { recursive: true });
+    const filePath = path.join(workspace.domainsPath, `${slugify(domain.name)}.md`);
+    await writeFile(filePath, renderDomainRecord(domain), "utf8");
+    return filePath;
+}
+export async function readCognitionNotes(workspace) {
+    if (!(await pathExists(workspace.cognitionPath))) {
+        return [];
+    }
+    const entries = await readdir(workspace.cognitionPath, { withFileTypes: true });
+    const notes = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".md")) {
+            continue;
+        }
+        const filePath = path.join(workspace.cognitionPath, entry.name);
+        const raw = await readFile(filePath, "utf8");
+        const encoded = raw.match(/```json\n([\s\S]*?)\n```/);
+        if (encoded) {
+            notes.push(JSON.parse(encoded[1]));
+        }
+    }
+    return notes;
+}
+export async function readDomainRecords(workspace) {
+    if (!(await pathExists(workspace.domainsPath))) {
+        return [];
+    }
+    const entries = await readdir(workspace.domainsPath, { withFileTypes: true });
+    const domains = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".md")) {
+            continue;
+        }
+        const raw = await readFile(path.join(workspace.domainsPath, entry.name), "utf8");
+        const encoded = raw.match(/```json\n([\s\S]*?)\n```/);
+        if (encoded) {
+            domains.push(JSON.parse(encoded[1]));
+        }
+    }
+    return domains;
+}
+export function slugify(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "");
+}
+function renderCognitionNote(note) {
+    const sectionText = Object.entries(note.sections)
+        .map(([heading, content]) => `## ${heading}\n\n${content.trim()}`)
+        .join("\n\n");
+    return `# ${note.title}\n\nStatus: ${note.referencesStatus}\n\n${sectionText}\n\n## KGraph Metadata\n\n\`\`\`json\n${JSON.stringify(note, null, 2)}\n\`\`\`\n`;
+}
+function renderDomainRecord(domain) {
+    return `# ${domain.name}\n\n${domain.description ?? ""}\n\n## Files\n\n${domain.files
+        .map((file) => `- ${file}`)
+        .join("\n")}\n\n## Symbols\n\n${domain.symbols
+        .map((symbol) => `- ${symbol}`)
+        .join("\n")}\n\n## Cognition Notes\n\n${domain.cognitionNotes
+        .map((note) => `- ${note}`)
+        .join("\n")}\n\n## KGraph Metadata\n\n\`\`\`json\n${JSON.stringify(domain, null, 2)}\n\`\`\`\n`;
+}

package/dist/storage/kgraph-paths.d.ts

@@ -0,0 +1,7 @@
+import type { KGraphWorkspace } from "../types/config.js";
+export declare function resolveWorkspace(rootPath?: string): KGraphWorkspace;
+export declare function pathExists(targetPath: string): Promise<boolean>;
+export declare function assertWorkspace(rootPath?: string): Promise<KGraphWorkspace>;
+export declare function ensureWorkspace(rootPath?: string): Promise<KGraphWorkspace>;
+export declare function toRepoPath(rootPath: string, targetPath: string): string;
+export declare function fromRepoPath(rootPath: string, repoPath: string): string;

package/dist/storage/kgraph-paths.js

@@ -0,0 +1,65 @@
+import { access, mkdir, stat } from "node:fs/promises";
+import path from "node:path";
+import { KGraphError } from "../cli/errors.js";
+const WORKSPACE_DIRS = [
+    "map",
+    "cognition",
+    "domains",
+    "inbox",
+    "interactions/processed",
+    "context"
+];
+export function resolveWorkspace(rootPath = process.cwd()) {
+    const kgraphPath = path.join(rootPath, ".kgraph");
+    return {
+        rootPath,
+        kgraphPath,
+        configPath: path.join(kgraphPath, "config.yaml"),
+        mapPath: path.join(kgraphPath, "map"),
+        cognitionPath: path.join(kgraphPath, "cognition"),
+        domainsPath: path.join(kgraphPath, "domains"),
+        inboxPath: path.join(kgraphPath, "inbox"),
+        processedInteractionsPath: path.join(kgraphPath, "interactions", "processed"),
+        contextPath: path.join(kgraphPath, "context")
+    };
+}
+export async function pathExists(targetPath) {
+    try {
+        await access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function assertWorkspace(rootPath = process.cwd()) {
+    const workspace = resolveWorkspace(rootPath);
+    if (!(await pathExists(workspace.kgraphPath))) {
+        throw new KGraphError("KGraph is not initialized. Run `kgraph init` first.");
+    }
+    const info = await stat(workspace.kgraphPath);
+    if (!info.isDirectory()) {
+        throw new KGraphError(".kgraph exists but is not a directory.");
+    }
+    return workspace;
+}
+export async function ensureWorkspace(rootPath = process.cwd()) {
+    const workspace = resolveWorkspace(rootPath);
+    if (await pathExists(workspace.kgraphPath)) {
+        const info = await stat(workspace.kgraphPath);
+        if (!info.isDirectory()) {
+            throw new KGraphError(".kgraph exists but is not a directory.");
+        }
+    }
+    await mkdir(workspace.kgraphPath, { recursive: true });
+    for (const dir of WORKSPACE_DIRS) {
+        await mkdir(path.join(workspace.kgraphPath, dir), { recursive: true });
+    }
+    return workspace;
+}
+export function toRepoPath(rootPath, targetPath) {
+    return path.relative(rootPath, targetPath).split(path.sep).join("/");
+}
+export function fromRepoPath(rootPath, repoPath) {
+    return path.join(rootPath, ...repoPath.split("/"));
+}

package/dist/storage/map-store.d.ts

@@ -0,0 +1,11 @@
+import type { KGraphWorkspace } from "../types/config.js";
+import type { DependencyMap, FileMap, RelationshipMap, ScanResult, SymbolMap } from "../types/maps.js";
+export declare function mapPaths(workspace: KGraphWorkspace): Record<string, string>;
+export declare function readMaps(workspace: KGraphWorkspace): Promise<{
+    fileMap: FileMap;
+    symbolMap: SymbolMap;
+    dependencyMap: DependencyMap;
+    relationshipMap: RelationshipMap;
+}>;
+export declare function writeMaps(workspace: KGraphWorkspace, result: ScanResult): Promise<void>;
+export declare function mapsExist(workspace: KGraphWorkspace): Promise<boolean>;

package/dist/storage/map-store.js

@@ -0,0 +1,60 @@
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { pathExists } from "./kgraph-paths.js";
+import { KGraphError } from "../cli/errors.js";
+async function readJson(filePath, fallback) {
+    if (!(await pathExists(filePath))) {
+        return fallback;
+    }
+    try {
+        return JSON.parse(await readFile(filePath, "utf8"));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new KGraphError(`Unable to read JSON map ${filePath}: ${message}`);
+    }
+}
+async function writeJson(filePath, value) {
+    await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+export function mapPaths(workspace) {
+    return {
+        files: path.join(workspace.mapPath, "files.json"),
+        symbols: path.join(workspace.mapPath, "symbols.json"),
+        dependencies: path.join(workspace.mapPath, "dependencies.json"),
+        relationships: path.join(workspace.mapPath, "relationships.json")
+    };
+}
+export async function readMaps(workspace) {
+    const paths = mapPaths(workspace);
+    return {
+        fileMap: await readJson(paths.files, { generatedAt: "", files: [] }),
+        symbolMap: await readJson(paths.symbols, { generatedAt: "", symbols: [] }),
+        dependencyMap: await readJson(paths.dependencies, { generatedAt: "", dependencies: [] }),
+        relationshipMap: await readJson(paths.relationships, {
+            generatedAt: "",
+            relationships: []
+        })
+    };
+}
+export async function writeMaps(workspace, result) {
+    const generatedAt = new Date().toISOString();
+    const paths = mapPaths(workspace);
+    await writeJson(paths.files, { generatedAt, files: result.files });
+    await writeJson(paths.symbols, { generatedAt, symbols: result.symbols });
+    await writeJson(paths.dependencies, {
+        generatedAt,
+        dependencies: result.dependencies
+    });
+    await writeJson(paths.relationships, {
+        generatedAt,
+        relationships: result.relationships
+    });
+}
+export async function mapsExist(workspace) {
+    const paths = mapPaths(workspace);
+    return ((await pathExists(paths.files)) &&
+        (await pathExists(paths.symbols)) &&
+        (await pathExists(paths.dependencies)) &&
+        (await pathExists(paths.relationships)));
+}

package/dist/types/cognition.d.ts

@@ -0,0 +1,43 @@
+import type { CodeSymbol, Relationship, RepositoryFile } from "./maps.js";
+export type ReferenceStatus = "current" | "stale" | "unresolved" | "mixed";
+export interface ParsedCognitionNote {
+    title: string;
+    domain?: string;
+    tags: string[];
+    summary?: string;
+    sections: Record<string, string>;
+    relatedFiles: string[];
+    relatedSymbols: string[];
+    warnings: string[];
+}
+export interface CognitionNote extends ParsedCognitionNote {
+    id: string;
+    sourceInboxPath: string;
+    processedPath: string;
+    createdAt: string;
+    referencesStatus: ReferenceStatus;
+}
+export interface DomainRecord {
+    name: string;
+    description?: string;
+    pathHints: string[];
+    tags: string[];
+    files: string[];
+    symbols: string[];
+    cognitionNotes: string[];
+}
+export interface RankedItem<T> {
+    item: T;
+    score: number;
+    reasons: string[];
+}
+export interface ContextResponse {
+    query: string;
+    matchedDomains: RankedItem<DomainRecord>[];
+    relevantFiles: RankedItem<RepositoryFile>[];
+    relevantSymbols: RankedItem<CodeSymbol>[];
+    relevantCognition: RankedItem<CognitionNote>[];
+    relationships: Relationship[];
+    staleReferences: string[];
+    warnings: string[];
+}

package/dist/types/cognition.js

@@ -0,0 +1 @@
+export {};

package/dist/types/config.d.ts

@@ -0,0 +1,24 @@
+export interface KGraphConfig {
+    include: string[];
+    exclude: string[];
+    languages: {
+        precise: string[];
+    };
+    maxContextItems: number;
+    domainHints: Record<string, DomainHint>;
+}
+export interface DomainHint {
+    paths?: string[];
+    tags?: string[];
+}
+export interface KGraphWorkspace {
+    rootPath: string;
+    kgraphPath: string;
+    configPath: string;
+    mapPath: string;
+    cognitionPath: string;
+    domainsPath: string;
+    inboxPath: string;
+    processedInteractionsPath: string;
+    contextPath: string;
+}

package/dist/types/config.js

@@ -0,0 +1 @@
+export {};