@kentwynn/kgraph 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kent Wynn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,200 @@
+# KGraph
+
+Persistent repo intelligence for AI coding assistants.
+
+KGraph is a local-first CLI for building an inspectable knowledge layer around a codebase. It helps AI coding sessions stop rediscovering the same repository structure, workflows, architecture decisions, and debugging history every time a new chat starts.
+
+## Why KGraph
+
+The biggest waste in AI-assisted coding is often not generation. It is repeated exploration:
+
+- rereading the same files
+- rediscovering the same architecture
+- re-inferring the same workflows
+- repeating prior debugging conclusions
+- spending tokens just to find the right place to work
+
+KGraph stores durable repository context in a local `.kgraph/` workspace so future AI sessions can navigate directly to relevant files, symbols, domains, and prior cognition.
+
+## What KGraph Is
+
+KGraph is:
+
+- persistent repo cognition
+- semantic navigation infrastructure
+- a context engineering layer
+- local filesystem-based project intelligence
+- an inspectable map of structure, relationships, and durable notes
+
+KGraph is not:
+
+- an AI coding assistant
+- a chatbot
+- a vector database
+- a simple RAG wrapper
+- a cloud service
+- an autonomous agent system
+
+## Install And Run
+
+KGraph is designed to feel like other developer-native CLI tools: one command to try it, optional global install if you use it often, and a quick version check before running commands.
+
+Public npm usage is the intended distribution path once the package is published.
+
+Install and run a specific stable release:
+
+```bash
+npx @kentwynn/kgraph@0.1.0 init
+```
+
+Or run the latest published release:
+
+```bash
+npx @kentwynn/kgraph@latest init
+```
+
+Use the CLI directly after initialization:
+
+```bash
+npx @kentwynn/kgraph@latest scan
+npx @kentwynn/kgraph@latest update
+npx @kentwynn/kgraph@latest context "auth token refresh"
+```
+
+Optional global installation:
+
+```bash
+npm install -g @kentwynn/kgraph@latest
+kgraph --version
+kgraph init
+kgraph scan
+kgraph update
+kgraph context "auth token refresh"
+```
+
+Current local development flow from a fresh clone:
+
+```bash
+npm install
+npm run build
+npm run kgraph -- --version
+npm run kgraph -- init
+npm run kgraph -- scan
+npm run kgraph -- update
+npm run kgraph -- context "auth token refresh"
+```
+
+Until the npm package is publicly released, use the local development commands or install directly from the release workflow artifact.
+
+## MVP CLI
+
+The MVP command surface is intentionally small:
+
+```bash
+kgraph init
+kgraph scan
+kgraph update
+kgraph context "auth token refresh"
+```
+
+`init` creates the local `.kgraph/` workspace. `scan` refreshes deterministic structure maps. `update` processes Markdown cognition notes. `context` returns compact repository context for a topic.
+
+The package is prepared for npm-style CLI distribution. The MVP includes CI and release artifact packaging, but automatic npm publishing is intentionally left for a later release policy.
+
+## Local-First Privacy
+
+KGraph writes project intelligence to local files in `.kgraph/`.
+
+The MVP does not require:
+
+- accounts
+- telemetry
+- cloud infrastructure
+- hosted services
+- databases
+- LLM providers
+- embeddings
+- vector search
+- background daemons
+
+Generated KGraph data is meant to be human-readable and inspectable with normal text tools.
+
+## MVP Scope
+
+The first version focuses on:
+
+- initializing `.kgraph/`
+- scanning repository files
+- extracting JavaScript and TypeScript symbols
+- writing file, symbol, dependency, and relationship maps
+- processing Markdown cognition notes
+- returning compact context for a query
+- keeping maps current as code changes
+
+Out of scope for the MVP:
+
+- npm publishing automation
+- deployment
+- cloud infrastructure
+- hosted dashboards
+- graph databases
+- vector databases
+- embeddings
+- autonomous agents
+- VS Code extension
+
+## CI
+
+The CI pipeline is intentionally small and practical. It runs on pushes to `main` and pull requests targeting `main`, and validates:
+
+```bash
+npm ci
+npm run build
+npm test
+npm pack --dry-run
+npm run check:artifacts
+```
+
+`check:artifacts` fails if local/generated Spec Kit or KGraph artifacts are committed by mistake, including:
+
+- `.kgraph/`
+- `.specify/`
+- `.agents/`
+- `AGENTS.md`
+- `REQUIREMENTS.md`
+- `specs/`
+
+## CD
+
+For a CLI package, CD means packaging an intentional release, not deploying infrastructure.
+
+KGraph includes a release package workflow that runs only when a maintainer pushes a version tag such as `v0.1.0` or starts the workflow manually. It repeats the core gates, creates the npm tarball, and uploads the package as a GitHub Actions artifact:
+
+```bash
+npm ci
+npm run build
+npm test
+npm run check:artifacts
+npm pack
+```
+
+This gives maintainers an inspectable package artifact before public npm publishing is enabled.
+
+## Roadmap
+
+Near-term:
+
+- stabilize the CLI contract
+- improve JS/TS symbol extraction
+- improve cognition note parsing
+- validate context quality against real repositories
+- make package publishing safe and intentional
+
+Later:
+
+- richer language scanners
+- Git-aware history and rename detection
+- optional MCP integration
+- optional editor integrations
+- visual graph exploration
+- optional LLM-assisted cognition extraction

package/dist/cli/commands/context.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerContextCommand(program: Command): void;

package/dist/cli/commands/context.js

@@ -0,0 +1,43 @@
+import { loadConfig } from "../../config/config.js";
+import { queryContext } from "../../context/context-query.js";
+import { assertWorkspace } from "../../storage/kgraph-paths.js";
+import { mapsExist, readMaps } from "../../storage/map-store.js";
+import { KGraphError, runCommand } from "../errors.js";
+export function registerContextCommand(program) {
+    program
+        .command("context <query>")
+        .description("Return compact repo context for a query")
+        .option("--json", "Print JSON output")
+        .action((query, options) => runCommand(async () => {
+        if (!query.trim()) {
+            throw new KGraphError("Query cannot be empty.");
+        }
+        const workspace = await assertWorkspace(process.cwd());
+        if (!(await mapsExist(workspace))) {
+            throw new KGraphError("KGraph maps are missing. Run `kgraph scan` first.");
+        }
+        const config = await loadConfig(workspace);
+        const maps = await readMaps(workspace);
+        const response = await queryContext(workspace, config, maps, query);
+        console.log(options.json ? JSON.stringify(response, null, 2) : renderMarkdown(response));
+    }));
+}
+function renderMarkdown(response) {
+    const lines = [`# KGraph Context`, ``, `Query: ${response.query}`, ``];
+    lines.push("## Matched Domains", "");
+    lines.push(...formatList(response.matchedDomains.map((item) => `- ${item.item.name} (${item.reasons.join(", ")})`)));
+    lines.push("", "## Relevant Files", "");
+    lines.push(...formatList(response.relevantFiles.map((item) => `- ${item.item.path} (${item.reasons.join(", ")})`)));
+    lines.push("", "## Relevant Symbols", "");
+    lines.push(...formatList(response.relevantSymbols.map((item) => `- ${item.item.name} in ${item.item.filePath}`)));
+    lines.push("", "## Relevant Cognition", "");
+    lines.push(...formatList(response.relevantCognition.map((item) => `- ${item.item.title} [${item.item.referencesStatus}]`)));
+    lines.push("", "## Relationships", "");
+    lines.push(...formatList(response.relationships.map((relationship) => `- ${relationship.sourceId} ${relationship.relationshipType} ${relationship.targetId} (${relationship.confidence})`)));
+    lines.push("", "## Stale References", "");
+    lines.push(...formatList(response.staleReferences.map((ref) => `- ${ref}`)));
+    return lines.join("\n");
+}
+function formatList(items) {
+    return items.length > 0 ? items : ["- None"];
+}

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerInitCommand(program: Command): void;

package/dist/cli/commands/init.js

@@ -0,0 +1,10 @@
+import { writeDefaultConfig } from "../../config/config.js";
+import { ensureWorkspace } from "../../storage/kgraph-paths.js";
+import { runCommand } from "../errors.js";
+export function registerInitCommand(program) {
+    program.command("init").description("Initialize a .kgraph workspace").action(() => runCommand(async () => {
+        const workspace = await ensureWorkspace(process.cwd());
+        const wroteConfig = await writeDefaultConfig(workspace);
+        console.log(wroteConfig ? "Initialized .kgraph workspace." : ".kgraph workspace already initialized.");
+    }));
+}

package/dist/cli/commands/scan.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerScanCommand(program: Command): void;

package/dist/cli/commands/scan.js

@@ -0,0 +1,32 @@
+import { refreshCognitionReferenceStatuses } from "../../cognition/cognition-updater.js";
+import { loadConfig } from "../../config/config.js";
+import { scanRepository } from "../../scanner/repo-scanner.js";
+import { assertWorkspace } from "../../storage/kgraph-paths.js";
+import { readMaps, writeMaps } from "../../storage/map-store.js";
+import { runCommand } from "../errors.js";
+export function registerScanCommand(program) {
+    program
+        .command("scan")
+        .description("Scan the repository into deterministic KGraph maps")
+        .option("--verbose", "Print scan warnings")
+        .action((options) => runCommand(async () => {
+        const workspace = await assertWorkspace(process.cwd());
+        const config = await loadConfig(workspace);
+        const previousMaps = await readMaps(workspace);
+        const result = await scanRepository(workspace.rootPath, config, {
+            files: previousMaps.fileMap.files,
+            symbols: previousMaps.symbolMap.symbols,
+            dependencies: previousMaps.dependencyMap.dependencies,
+            relationships: previousMaps.relationshipMap.relationships,
+            warnings: []
+        });
+        await writeMaps(workspace, result);
+        await refreshCognitionReferenceStatuses(workspace, { files: result.files, symbols: result.symbols });
+        console.log(`Scanned ${result.files.length} files and ${result.symbols.length} symbols.`);
+        if (options.verbose && result.warnings.length > 0) {
+            for (const warning of result.warnings) {
+                console.warn(`Warning: ${warning}`);
+            }
+        }
+    }));
+}

package/dist/cli/commands/update.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerUpdateCommand(program: Command): void;

package/dist/cli/commands/update.js

@@ -0,0 +1,19 @@
+import { updateCognition } from "../../cognition/cognition-updater.js";
+import { assertWorkspace } from "../../storage/kgraph-paths.js";
+import { readMaps } from "../../storage/map-store.js";
+import { runCommand } from "../errors.js";
+export function registerUpdateCommand(program) {
+    program
+        .command("update")
+        .description("Process Markdown cognition notes from .kgraph/inbox")
+        .option("--dry-run", "Parse notes without writing cognition files")
+        .action((options) => runCommand(async () => {
+        const workspace = await assertWorkspace(process.cwd());
+        const maps = await readMaps(workspace);
+        const result = await updateCognition(workspace, { files: maps.fileMap.files, symbols: maps.symbolMap.symbols }, Boolean(options.dryRun));
+        console.log(`${options.dryRun ? "Parsed" : "Processed"} ${result.processed.length} cognition notes.`);
+        for (const warning of result.warnings) {
+            console.warn(`Warning: ${warning}`);
+        }
+    }));
+}

package/dist/cli/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class KGraphError extends Error {
+    readonly exitCode: number;
+    constructor(message: string, exitCode?: number);
+}
+export declare function runCommand(action: () => Promise<void>): Promise<void>;

package/dist/cli/errors.js

@@ -0,0 +1,23 @@
+export class KGraphError extends Error {
+    exitCode;
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.exitCode = exitCode;
+        this.name = "KGraphError";
+    }
+}
+export async function runCommand(action) {
+    try {
+        await action();
+    }
+    catch (error) {
+        if (error instanceof KGraphError) {
+            console.error(`Error: ${error.message}`);
+            process.exitCode = error.exitCode;
+            return;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Unexpected error: ${message}`);
+        process.exitCode = 1;
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+export declare function createProgram(): Command;

package/dist/cli/index.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { registerInitCommand } from "./commands/init.js";
+import { registerScanCommand } from "./commands/scan.js";
+import { registerUpdateCommand } from "./commands/update.js";
+import { registerContextCommand } from "./commands/context.js";
+export function createProgram() {
+    const program = new Command();
+    program
+        .name("kgraph")
+        .description("Persistent repo intelligence for AI coding assistants")
+        .version("0.1.0");
+    registerInitCommand(program);
+    registerScanCommand(program);
+    registerUpdateCommand(program);
+    registerContextCommand(program);
+    return program;
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    await createProgram().parseAsync(process.argv);
+}

package/dist/cognition/cognition-updater.d.ts

@@ -0,0 +1,10 @@
+import type { KGraphWorkspace } from "../types/config.js";
+import type { CognitionNote, ReferenceStatus } from "../types/cognition.js";
+import type { ScanResult } from "../types/maps.js";
+export interface UpdateResult {
+    processed: CognitionNote[];
+    warnings: string[];
+}
+export declare function updateCognition(workspace: KGraphWorkspace, currentMaps: Pick<ScanResult, "files" | "symbols">, dryRun?: boolean): Promise<UpdateResult>;
+export declare function refreshCognitionReferenceStatuses(workspace: KGraphWorkspace, currentMaps: Pick<ScanResult, "files" | "symbols">): Promise<void>;
+export declare function evaluateReferenceStatus(relatedFiles: string[], relatedSymbols: string[], currentMaps: Pick<ScanResult, "files" | "symbols">): ReferenceStatus;

package/dist/cognition/cognition-updater.js

@@ -0,0 +1,77 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { parseMarkdownNote } from "./markdown-note-parser.js";
+import { archiveInboxNote, readCognitionNotes, listInboxNotes, slugify, writeCognitionNote, writeDomainRecord } from "../storage/cognition-store.js";
+export async function updateCognition(workspace, currentMaps, dryRun = false) {
+    const inboxNotes = await listInboxNotes(workspace);
+    const processed = [];
+    const warnings = [];
+    for (const inboxPath of inboxNotes) {
+        try {
+            const raw = await readFile(inboxPath, "utf8");
+            const parsed = parseMarkdownNote(raw);
+            const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+            const id = `${timestamp}-${slugify(parsed.title) || path.basename(inboxPath, ".md")}`;
+            const archivedPath = path.join(workspace.processedInteractionsPath, `${timestamp}-${path.basename(inboxPath)}`);
+            const note = {
+                ...parsed,
+                id,
+                sourceInboxPath: path.relative(workspace.rootPath, inboxPath).split(path.sep).join("/"),
+                processedPath: path.relative(workspace.rootPath, archivedPath).split(path.sep).join("/"),
+                createdAt: new Date().toISOString(),
+                referencesStatus: evaluateReferenceStatus(parsed.relatedFiles, parsed.relatedSymbols, currentMaps)
+            };
+            processed.push(note);
+            warnings.push(...parsed.warnings.map((warning) => `${path.basename(inboxPath)}: ${warning}`));
+            if (!dryRun) {
+                await archiveInboxNote(workspace, inboxPath, timestamp);
+                await writeCognitionNote(workspace, note);
+                await writeDomainRecord(workspace, toDomainRecord(note, currentMaps));
+            }
+        }
+        catch (error) {
+            warnings.push(`${path.basename(inboxPath)}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return { processed, warnings };
+}
+export async function refreshCognitionReferenceStatuses(workspace, currentMaps) {
+    const notes = await readCognitionNotes(workspace);
+    for (const note of notes) {
+        const nextStatus = evaluateReferenceStatus(note.relatedFiles, note.relatedSymbols, currentMaps);
+        if (nextStatus !== note.referencesStatus) {
+            await writeCognitionNote(workspace, { ...note, referencesStatus: nextStatus });
+        }
+    }
+}
+export function evaluateReferenceStatus(relatedFiles, relatedSymbols, currentMaps) {
+    const filePaths = new Set(currentMaps.files.map((file) => file.path));
+    const symbolNames = new Set(currentMaps.symbols.map((symbol) => symbol.name));
+    const references = [
+        ...relatedFiles.map((file) => filePaths.has(file)),
+        ...relatedSymbols.map((symbol) => symbolNames.has(symbol))
+    ];
+    if (references.length === 0) {
+        return "unresolved";
+    }
+    if (references.every(Boolean)) {
+        return "current";
+    }
+    if (references.every((value) => !value)) {
+        return "stale";
+    }
+    return "mixed";
+}
+function toDomainRecord(note, currentMaps) {
+    const name = note.domain ?? "general";
+    const fileSet = new Set(currentMaps.files.map((file) => file.path));
+    const symbolSet = new Set(currentMaps.symbols.map((symbol) => symbol.name));
+    return {
+        name,
+        pathHints: note.relatedFiles,
+        tags: note.tags,
+        files: note.relatedFiles.filter((file) => fileSet.has(file)),
+        symbols: note.relatedSymbols.filter((symbol) => symbolSet.has(symbol)),
+        cognitionNotes: [note.id]
+    };
+}

package/dist/cognition/markdown-note-parser.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedCognitionNote } from "../types/cognition.js";
+export declare function parseMarkdownNote(markdown: string): ParsedCognitionNote;

package/dist/cognition/markdown-note-parser.js

@@ -0,0 +1,71 @@
+import YAML from "yaml";
+const PATH_REF = /(?:^|\s)([\w./-]+\.(?:ts|tsx|js|jsx|json|md|yaml|yml))(?:\s|$|[),.;])/g;
+const SYMBOL_REF = /`?([A-Za-z_$][\w$]{2,})`?/g;
+export function parseMarkdownNote(markdown) {
+    const warnings = [];
+    const { frontmatter, body } = splitFrontmatter(markdown, warnings);
+    const sections = parseSections(body);
+    const frontmatterTitle = typeof frontmatter.title === "string" ? frontmatter.title : undefined;
+    const title = extractTitle(body) ?? frontmatterTitle ?? "Untitled Cognition Note";
+    const combined = Object.values(sections).join("\n");
+    return {
+        title,
+        domain: typeof frontmatter.domain === "string" ? frontmatter.domain : undefined,
+        tags: Array.isArray(frontmatter.tags) ? frontmatter.tags.map(String) : [],
+        summary: sections.Summary,
+        sections,
+        relatedFiles: unique(extractMatches(combined, PATH_REF)),
+        relatedSymbols: unique(extractSymbolRefs(combined)),
+        warnings
+    };
+}
+function splitFrontmatter(markdown, warnings) {
+    if (!markdown.startsWith("---\n")) {
+        return { frontmatter: {}, body: markdown };
+    }
+    const end = markdown.indexOf("\n---", 4);
+    if (end === -1) {
+        warnings.push("Frontmatter start found without closing delimiter.");
+        return { frontmatter: {}, body: markdown };
+    }
+    try {
+        return {
+            frontmatter: (YAML.parse(markdown.slice(4, end)) ?? {}),
+            body: markdown.slice(end + 4)
+        };
+    }
+    catch (error) {
+        warnings.push(`Invalid frontmatter: ${error instanceof Error ? error.message : String(error)}`);
+        return { frontmatter: {}, body: markdown.slice(end + 4) };
+    }
+}
+function extractTitle(body) {
+    return body.match(/^#\s+(.+)$/m)?.[1]?.trim();
+}
+function parseSections(body) {
+    const sections = {};
+    const matches = [...body.matchAll(/^##\s+(.+)$/gm)];
+    for (let index = 0; index < matches.length; index += 1) {
+        const match = matches[index];
+        const heading = match[1].trim();
+        const start = (match.index ?? 0) + match[0].length;
+        const end = matches[index + 1]?.index ?? body.length;
+        sections[heading] = body.slice(start, end).trim();
+    }
+    if (Object.keys(sections).length === 0) {
+        sections.Summary = body.replace(/^#\s+.+$/m, "").trim();
+    }
+    return sections;
+}
+function extractMatches(text, regex) {
+    return [...text.matchAll(regex)].map((match) => match[1]);
+}
+function extractSymbolRefs(text) {
+    const stopwords = new Set(["Summary", "Related", "Files", "Functions", "Decisions", "Debugging", "Conclusions"]);
+    return [...text.matchAll(SYMBOL_REF)]
+        .map((match) => match[1])
+        .filter((item) => !stopwords.has(item) && !item.includes("."));
+}
+function unique(items) {
+    return [...new Set(items)];
+}

package/dist/config/config.d.ts

@@ -0,0 +1,5 @@
+import type { KGraphConfig, KGraphWorkspace } from "../types/config.js";
+export declare const DEFAULT_CONFIG: KGraphConfig;
+export declare function writeDefaultConfig(workspace: KGraphWorkspace): Promise<boolean>;
+export declare function loadConfig(workspace: KGraphWorkspace): Promise<KGraphConfig>;
+export declare function normalizeConfig(config: Partial<KGraphConfig>): KGraphConfig;

package/dist/config/config.js

@@ -0,0 +1,49 @@
+import { readFile, writeFile } from "node:fs/promises";
+import YAML from "yaml";
+import { pathExists } from "../storage/kgraph-paths.js";
+import { KGraphError } from "../cli/errors.js";
+export const DEFAULT_CONFIG = {
+    include: ["**/*"],
+    exclude: [".git", "node_modules", "dist", "build", ".next", "coverage", ".kgraph"],
+    languages: {
+        precise: [".js", ".jsx", ".ts", ".tsx"]
+    },
+    maxContextItems: 8,
+    domainHints: {}
+};
+export async function writeDefaultConfig(workspace) {
+    if (await pathExists(workspace.configPath)) {
+        return false;
+    }
+    await writeFile(workspace.configPath, YAML.stringify(DEFAULT_CONFIG), "utf8");
+    return true;
+}
+export async function loadConfig(workspace) {
+    if (!(await pathExists(workspace.configPath))) {
+        return DEFAULT_CONFIG;
+    }
+    try {
+        const raw = await readFile(workspace.configPath, "utf8");
+        const parsed = YAML.parse(raw);
+        return normalizeConfig(parsed ?? {});
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new KGraphError(`Invalid config at ${workspace.configPath}: ${message}`);
+    }
+}
+export function normalizeConfig(config) {
+    return {
+        include: Array.isArray(config.include) ? config.include : DEFAULT_CONFIG.include,
+        exclude: Array.isArray(config.exclude) ? config.exclude : DEFAULT_CONFIG.exclude,
+        languages: {
+            precise: Array.isArray(config.languages?.precise)
+                ? config.languages.precise
+                : DEFAULT_CONFIG.languages.precise
+        },
+        maxContextItems: typeof config.maxContextItems === "number" && config.maxContextItems > 0
+            ? config.maxContextItems
+            : DEFAULT_CONFIG.maxContextItems,
+        domainHints: config.domainHints && typeof config.domainHints === "object" ? config.domainHints : {}
+    };
+}

package/dist/context/context-query.d.ts

@@ -0,0 +1,10 @@
+import type { KGraphConfig } from "../types/config.js";
+import type { ContextResponse } from "../types/cognition.js";
+import type { DependencyMap, FileMap, RelationshipMap, SymbolMap } from "../types/maps.js";
+import type { KGraphWorkspace } from "../types/config.js";
+export declare function queryContext(workspace: KGraphWorkspace, config: KGraphConfig, maps: {
+    fileMap: FileMap;
+    symbolMap: SymbolMap;
+    dependencyMap: DependencyMap;
+    relationshipMap: RelationshipMap;
+}, query: string): Promise<ContextResponse>;