@kentwynn/kgraph 0.1.5 → 0.1.7

package/README.md

@@ -84,12 +84,12 @@ kgraph context "auth token refresh" --json
 
 KGraph writes local instruction files and command/prompt packs so AI tools can use the repository knowledge layer during normal coding chats.
 
-| Integration | Always-on guidance | KGraph command assets |
-| --- | --- | --- |
-| Codex | `AGENTS.md` | `.agents/skills/kgraph/SKILL.md` |
+| Integration    | Always-on guidance                | KGraph command assets              |
+| -------------- | --------------------------------- | ---------------------------------- |
+| Codex          | `AGENTS.md`                       | `.agents/skills/kgraph/SKILL.md`   |
 | GitHub Copilot | `.github/copilot-instructions.md` | `.github/prompts/kgraph.prompt.md` |
-| Cursor | `.cursor/rules/kgraph.mdc` | Built into the KGraph Cursor rule |
-| Claude Code | `CLAUDE.md` | `.claude/commands/kgraph.md` |
+| Cursor         | `.cursor/rules/kgraph.mdc`        | Built into the KGraph Cursor rule  |
+| Claude Code    | `CLAUDE.md`                       | `.claude/commands/kgraph.md`       |
 
 Example:
 
@@ -150,7 +150,21 @@ KGraph stores project intelligence in local files inside `.kgraph/`. The MVP doe
 npm install
 npm run build
 npm test
+```
+
+Test a command without installing:
+
+```bash
 npm run kgraph -- init --integrations codex,cursor
+npm run kgraph -- context "auth token refresh"
+```
+
+Install the local build globally to test the `kgraph` binary end-to-end:
+
+```bash
+npm install -g .
+kgraph --version
+kgraph init --integrations codex,copilot
 ```
 
 ## Release

package/dist/cli/index.d.ts

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

package/dist/cli/index.js

@@ -1,23 +1,26 @@
 #!/usr/bin/env node
-import { realpathSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-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";
-import { registerIntegrateCommand } from "./commands/integrate.js";
-import { renderRootHelp } from "./help.js";
+import { Command } from 'commander';
+import { realpathSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { registerContextCommand } from './commands/context.js';
+import { registerInitCommand } from './commands/init.js';
+import { registerIntegrateCommand } from './commands/integrate.js';
+import { registerScanCommand } from './commands/scan.js';
+import { registerUpdateCommand } from './commands/update.js';
+import { renderRootHelp } from './help.js';
+const require = createRequire(import.meta.url);
+const { version } = require('../../package.json');
 export function createProgram() {
     const program = new Command();
     program
-        .name("kgraph")
-        .description("Persistent repo intelligence for AI coding assistants")
-        .version("0.1.2")
-        .addHelpText("beforeAll", renderRootHelp())
+        .name('kgraph')
+        .description('Persistent repo intelligence for AI coding assistants')
+        .version(version)
+        .addHelpText('beforeAll', renderRootHelp())
         .helpOption(false);
-    program.option("-h, --help", "Show this help");
-    program.hook("preAction", (thisCommand) => {
+    program.option('-h, --help', 'Show this help');
+    program.hook('preAction', (thisCommand) => {
         if (thisCommand.opts().help) {
             console.log(renderRootHelp());
             process.exitCode = 0;
@@ -32,7 +35,9 @@ export function createProgram() {
 }
 if (isCliEntrypoint()) {
     const program = createProgram();
-    if (process.argv.length <= 2 || process.argv.includes("-h") || process.argv.includes("--help")) {
+    if (process.argv.length <= 2 ||
+        process.argv.includes('-h') ||
+        process.argv.includes('--help')) {
         console.log(renderRootHelp());
     }
     else {
@@ -44,7 +49,8 @@ function isCliEntrypoint() {
         return false;
     }
     try {
-        return realpathSync(fileURLToPath(import.meta.url)) === realpathSync(process.argv[1]);
+        return (realpathSync(fileURLToPath(import.meta.url)) ===
+            realpathSync(process.argv[1]));
     }
     catch {
         return import.meta.url === `file://${process.argv[1]}`;

package/dist/config/config.d.ts

@@ -1,4 +1,4 @@
-import type { KGraphConfig, KGraphWorkspace } from "../types/config.js";
+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 saveConfig(workspace: KGraphWorkspace, config: KGraphConfig): Promise<void>;

package/dist/config/config.js

@@ -1,62 +1,62 @@
-import { readFile, writeFile } from "node:fs/promises";
-import YAML from "yaml";
-import { pathExists } from "../storage/kgraph-paths.js";
-import { KGraphError } from "../cli/errors.js";
+import { readFile, writeFile } from 'node:fs/promises';
+import YAML from 'yaml';
+import { KGraphError } from '../cli/errors.js';
+import { pathExists } from '../storage/kgraph-paths.js';
 export const DEFAULT_CONFIG = {
-    include: ["**/*"],
+    include: ['**/*'],
     exclude: [
-        ".git",
-        "node_modules",
-        "dist",
-        "build",
-        ".next",
-        "coverage",
-        ".kgraph",
-        ".npm-cache",
-        ".cache",
-        ".turbo",
-        ".vite",
-        ".nuxt",
-        ".output",
-        ".vercel",
-        ".serverless",
-        ".agents",
-        ".specify",
-        "specs",
-        ".cursor",
-        ".claude",
-        ".github/copilot-instructions.md",
-        ".github/prompts",
-        "AGENTS.md",
-        "CLAUDE.md",
-        "REQUIREMENTS.md",
-        "*.log",
-        "*.tgz",
-        ".DS_Store"
+        '.git',
+        'node_modules',
+        'dist',
+        'build',
+        '.next',
+        'coverage',
+        '.kgraph',
+        '.npm-cache',
+        '.cache',
+        '.turbo',
+        '.vite',
+        '.nuxt',
+        '.output',
+        '.vercel',
+        '.serverless',
+        '.agents',
+        '.specify',
+        'specs',
+        '.cursor',
+        '.claude',
+        '.github/copilot-instructions.md',
+        '.github/prompts',
+        'AGENTS.md',
+        'CLAUDE.md',
+        'REQUIREMENTS.md',
+        '*.log',
+        '*.tgz',
+        '.DS_Store',
     ],
     languages: {
-        precise: [".js", ".jsx", ".ts", ".tsx"]
+        precise: ['.js', '.jsx', '.ts', '.tsx'],
     },
     maxContextItems: 8,
     domainHints: {},
-    integrations: []
+    integrations: [],
 };
 export async function writeDefaultConfig(workspace) {
     if (await pathExists(workspace.configPath)) {
         return false;
     }
-    await writeFile(workspace.configPath, YAML.stringify(DEFAULT_CONFIG), "utf8");
+    await writeFile(workspace.configPath, YAML.stringify(DEFAULT_CONFIG), 'utf8');
     return true;
 }
 export async function saveConfig(workspace, config) {
-    await writeFile(workspace.configPath, YAML.stringify(config), "utf8");
+    await writeFile(workspace.configPath, YAML.stringify(config), 'utf8');
 }
 export async function loadConfig(workspace) {
     if (!(await pathExists(workspace.configPath))) {
         return DEFAULT_CONFIG;
     }
     try {
-        const raw = await readFile(workspace.configPath, "utf8");
+        const raw = await readFile(workspace.configPath, 'utf8');
         const parsed = YAML.parse(raw);
         return normalizeConfig(parsed ?? {});
     }
@@ -67,18 +67,22 @@ export async function loadConfig(workspace) {
 }
 export function normalizeConfig(config) {
     return {
-        include: Array.isArray(config.include) ? config.include : DEFAULT_CONFIG.include,
+        include: Array.isArray(config.include)
+            ? config.include
+            : DEFAULT_CONFIG.include,
         exclude: mergeUnique(DEFAULT_CONFIG.exclude, Array.isArray(config.exclude) ? config.exclude : []),
         languages: {
             precise: Array.isArray(config.languages?.precise)
                 ? config.languages.precise
-                : DEFAULT_CONFIG.languages.precise
+                : DEFAULT_CONFIG.languages.precise,
         },
-        maxContextItems: typeof config.maxContextItems === "number" && config.maxContextItems > 0
+        maxContextItems: typeof config.maxContextItems === 'number' && config.maxContextItems > 0
             ? config.maxContextItems
             : DEFAULT_CONFIG.maxContextItems,
-        domainHints: config.domainHints && typeof config.domainHints === "object" ? config.domainHints : {},
-        integrations: normalizeIntegrations(config.integrations)
+        domainHints: config.domainHints && typeof config.domainHints === 'object'
+            ? config.domainHints
+            : {},
+        integrations: normalizeIntegrations(config.integrations),
     };
 }
 function mergeUnique(base, extra) {
@@ -91,23 +95,23 @@ function normalizeIntegrations(value) {
     const seen = new Set();
     const integrations = [];
     for (const item of value) {
-        if (!item || typeof item !== "object") {
+        if (!item || typeof item !== 'object') {
             continue;
         }
         const candidate = item;
-        if (typeof candidate.name !== "string" ||
-            typeof candidate.targetPath !== "string" ||
+        if (typeof candidate.name !== 'string' ||
+            typeof candidate.targetPath !== 'string' ||
             seen.has(candidate.name)) {
             continue;
         }
-        if (!["claude-code", "codex", "copilot", "cursor"].includes(candidate.name)) {
+        if (!['claude-code', 'codex', 'copilot', 'cursor'].includes(candidate.name)) {
             continue;
         }
         seen.add(candidate.name);
         integrations.push({
             name: candidate.name,
             enabled: candidate.enabled !== false,
-            targetPath: candidate.targetPath
+            targetPath: candidate.targetPath,
         });
     }
     return integrations;

package/dist/integrations/adapters/claude-code.d.ts

@@ -1,2 +1,2 @@
-import type { IntegrationAdapter } from "../integration-registry.js";
+import type { IntegrationAdapter } from '../integration-registry.js';
 export declare const claudeCodeAdapter: IntegrationAdapter;

package/dist/integrations/adapters/claude-code.js

@@ -1,27 +1,33 @@
 export const claudeCodeAdapter = {
-    name: "claude-code",
-    label: "Claude Code",
-    targetPath: "CLAUDE.md",
+    name: 'claude-code',
+    label: 'Claude Code',
+    targetPath: 'CLAUDE.md',
     instructions: `## KGraph Workflow
 
-- Start repository work by checking \`kgraph context "<topic>"\` when the user asks about a domain, bug, workflow, or feature.
-- Convert stable discoveries from chat into Markdown notes under \`.kgraph/inbox/\`.
-- Run \`kgraph update\` to preserve those notes as durable cognition.
-- Run \`kgraph scan\` after structural code changes.
-- Run \`kgraph visualize\` when visualization support is available and the user wants to inspect the current knowledge map.
+Before exploring the repository, run \`kgraph context "<topic>"\` to load existing repo intelligence. Use /kgraph for the full automated workflow. Run \`kgraph scan\` and \`kgraph update\` manually when needed.
 `,
     commandFiles: [
         {
-            path: ".claude/commands/kgraph.md",
+            path: '.claude/commands/kgraph.md',
             content: `Use KGraph persistent repo intelligence for the current request.
 
 1. Infer the topic from the user's request.
 2. Run \`kgraph context "<topic>"\`.
 3. Use the returned files, symbols, relationships, and cognition before broad exploration.
-4. Save durable discoveries to \`.kgraph/inbox/\` and run \`kgraph update\` when appropriate.
-5. Run \`kgraph scan\` after structural changes and report the scan summary.
-`
-        }
+4. Save durable discoveries to \`.kgraph/inbox/\` and immediately run \`kgraph update\`.
+5. If you created, moved, deleted, or renamed files or symbols during this session, run \`kgraph scan\` and report the summary. Skip it otherwise.
+`,
+        },
+        {
+            path: '.claude/commands/kgraph-scan.md',
+            content: `Run \`kgraph scan\` to refresh the repository maps, then summarize what changed.
+`,
+        },
+        {
+            path: '.claude/commands/kgraph-update.md',
+            content: `Run \`kgraph update\` to process any pending Markdown notes in \`.kgraph/inbox/\` into durable cognition.
+`,
+        },
     ],
-    obsoleteCommandFiles: [".claude/commands/kgraph-update.md", ".claude/commands/kgraph-scan.md"]
+    obsoleteCommandFiles: [],
 };

package/dist/integrations/adapters/codex.d.ts

@@ -1,2 +1,2 @@
-import type { IntegrationAdapter } from "../integration-registry.js";
+import type { IntegrationAdapter } from '../integration-registry.js';
 export declare const codexAdapter: IntegrationAdapter;

package/dist/integrations/adapters/codex.js

@@ -1,35 +1,33 @@
 export const codexAdapter = {
-    name: "codex",
-    label: "Codex",
-    targetPath: "AGENTS.md",
+    name: 'codex',
+    label: 'Codex',
+    targetPath: 'AGENTS.md',
     instructions: `## KGraph Workflow
 
-- Before broad repository exploration, run \`kgraph context "<topic>"\` to load current repo intelligence.
-- After useful debugging, architecture discovery, workflow learning, or implementation work, write a concise Markdown note into \`.kgraph/inbox/\`.
-- Run \`kgraph update\` after adding inbox notes so KGraph preserves durable cognition.
-- Run \`kgraph scan\` after file moves, function renames, refactors, or other structural changes.
-- When visualization support is available and the developer asks to inspect KGraph, run \`kgraph visualize\` and report the generated local artifact.
+Before exploring the repository, run \`kgraph context "<topic>"\` to load existing repo intelligence. The /kgraph skill handles the full automated workflow. Run \`kgraph scan\` and \`kgraph update\` manually when needed.
 `,
     commandFiles: [
         {
-            path: ".agents/skills/kgraph/SKILL.md",
+            path: '.agents/skills/kgraph/SKILL.md',
             content: `---
-name: "kgraph"
-description: "Use KGraph persistent repo intelligence for the current coding task."
+name: kgraph
+description: Use KGraph persistent repo intelligence before broad repository exploration. Use when asked about repo structure, debugging context, architecture decisions, or to avoid rediscovering what is already known.
 ---
 
-Use this skill when the user asks to use KGraph, requests repo context, or asks you to avoid rediscovering repository structure.
+# KGraph Skill
 
 Workflow:
 
 1. Infer the current topic from the user request.
 2. Run \`kgraph context "<topic>"\` before broad repo exploration.
-3. Use KGraph's files, symbols, relationships, and cognition as navigation hints.
-4. After durable discoveries, write a concise Markdown note to \`.kgraph/inbox/\`.
-5. Run \`kgraph update\` if you created an inbox note.
-6. Run \`kgraph scan\` after structural changes.
-`
-        }
+3. Use KGraph's returned files, symbols, relationships, and cognition as navigation hints.
+4. After durable discoveries, write a concise Markdown note to \`.kgraph/inbox/\` and immediately run \`kgraph update\`.
+5. If you created, moved, deleted, or renamed files or symbols during this session, run \`kgraph scan\`. Skip it otherwise.
+`,
+        },
+    ],
+    obsoleteCommandFiles: [
+        '.agents/skills/kgraph-update',
+        '.agents/skills/kgraph-scan',
     ],
-    obsoleteCommandFiles: [".agents/skills/kgraph-update", ".agents/skills/kgraph-scan"]
 };

package/dist/integrations/adapters/copilot.d.ts

@@ -1,2 +1,2 @@
-import type { IntegrationAdapter } from "../integration-registry.js";
+import type { IntegrationAdapter } from '../integration-registry.js';
 export declare const copilotAdapter: IntegrationAdapter;

package/dist/integrations/adapters/copilot.js

@@ -1,32 +1,32 @@
 export const copilotAdapter = {
-    name: "copilot",
-    label: "GitHub Copilot",
-    targetPath: ".github/copilot-instructions.md",
+    name: 'copilot',
+    label: 'GitHub Copilot',
+    targetPath: '.github/copilot-instructions.md',
     instructions: `## KGraph Workflow
 
-- Use \`kgraph context "<topic>"\` before scanning many files manually.
-- Preserve stable findings by creating Markdown notes in \`.kgraph/inbox/\`.
-- Use \`kgraph update\` to process chat summaries and debugging conclusions into durable cognition.
-- Use \`kgraph scan\` when code structure changes.
-- Use \`kgraph visualize\` when visualization support is available and the developer asks to inspect the repository knowledge map.
+Before exploring the repository, run \`kgraph context "<topic>"\` to load existing repo intelligence. Use /kgraph-scan and /kgraph-update for manual maintenance.
 `,
     commandFiles: [
         {
-            path: ".github/prompts/kgraph.prompt.md",
+            path: '.github/prompts/kgraph-scan.prompt.md',
             content: `---
 mode: agent
-description: Use KGraph persistent repo intelligence for this request
+description: Refresh KGraph file, symbol, import, and relationship maps
 ---
 
-Use KGraph for the current task.
+Run \`kgraph scan\` to refresh the repository maps, then summarize what changed.
+`,
+        },
+        {
+            path: '.github/prompts/kgraph-update.prompt.md',
+            content: `---
+mode: agent
+description: Process KGraph inbox notes into durable cognition
+---
 
-1. If the user provided a topic, run \`kgraph context "<topic>"\` first. If not, infer a concise topic from the request.
-2. Use the returned files, symbols, relationships, and cognition before broad repository exploration.
-3. If you discover durable architecture, debugging, workflow, or gotcha knowledge, create a Markdown note in \`.kgraph/inbox/\`.
-4. If you add an inbox note, run \`kgraph update\`.
-5. If code structure changed, run \`kgraph scan\`.
-`
-        }
+Run \`kgraph update\` to process any pending Markdown notes in \`.kgraph/inbox/\` into durable cognition.
+`,
+        },
     ],
-    obsoleteCommandFiles: [".github/prompts/kgraph-update.prompt.md", ".github/prompts/kgraph-scan.prompt.md"]
+    obsoleteCommandFiles: ['.github/prompts/kgraph.prompt.md'],
 };

package/dist/integrations/adapters/cursor.d.ts

@@ -1,2 +1,2 @@
-import type { IntegrationAdapter } from "../integration-registry.js";
+import type { IntegrationAdapter } from '../integration-registry.js';
 export declare const cursorAdapter: IntegrationAdapter;

package/dist/integrations/adapters/cursor.js

@@ -1,7 +1,7 @@
 export const cursorAdapter = {
-    name: "cursor",
-    label: "Cursor",
-    targetPath: ".cursor/rules/kgraph.mdc",
+    name: 'cursor',
+    label: 'Cursor',
+    targetPath: '.cursor/rules/kgraph.mdc',
     instructions: `---
 description: Use KGraph persistent repo intelligence before broad repository exploration
 alwaysApply: true
@@ -9,11 +9,7 @@ alwaysApply: true
 
 ## KGraph Workflow
 
-- Query \`kgraph context "<topic>"\` before broad file searches when repo cognition may already exist.
-- Store durable chat, debugging, architecture, and workflow discoveries as Markdown notes in \`.kgraph/inbox/\`.
-- Run \`kgraph update\` after adding useful notes.
-- Run \`kgraph scan\` after refactors, moved folders, renamed functions, or other structure changes.
-- Run \`kgraph visualize\` when visualization support is available and the developer asks to inspect the KGraph map.
+Before exploring the repository, run \`kgraph context "<topic>"\` to load existing repo intelligence. Run \`kgraph scan\` and \`kgraph update\` manually when needed.
 `,
-    obsoleteCommandFiles: [".cursor/rules/kgraph-commands.mdc"]
+    obsoleteCommandFiles: ['.cursor/rules/kgraph-commands.mdc'],
 };

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

@@ -1,5 +1,6 @@
-import type { KGraphConfig } from "../types/config.js";
+import type { KGraphConfig } from '../types/config.js';
 export declare function shouldExclude(repoPath: string, config: KGraphConfig): boolean;
 export declare function buildFastGlobIgnore(exclude: string[]): string[];
+export declare function readGitignorePatterns(rootPath: string): Promise<string[]>;
 export declare function detectLanguage(filePath: string): string;
 export declare function isPreciseLanguage(filePath: string, config: KGraphConfig): boolean;

package/dist/scanner/file-classifier.js

@@ -1,13 +1,88 @@
-import path from "node:path";
+import { readFile } from 'node:fs/promises';
+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"
+    // JavaScript / TypeScript
+    '.js': 'javascript',
+    '.jsx': 'javascriptreact',
+    '.ts': 'typescript',
+    '.tsx': 'typescriptreact',
+    '.mjs': 'javascript',
+    '.cjs': 'javascript',
+    '.mts': 'typescript',
+    '.cts': 'typescript',
+    // Python
+    '.py': 'python',
+    '.pyw': 'python',
+    '.pyi': 'python',
+    // Go
+    '.go': 'go',
+    // Rust
+    '.rs': 'rust',
+    // Java / JVM
+    '.java': 'java',
+    '.kt': 'kotlin',
+    '.kts': 'kotlin',
+    '.scala': 'scala',
+    '.groovy': 'groovy',
+    // C / C++
+    '.c': 'c',
+    '.h': 'c',
+    '.cpp': 'cpp',
+    '.cc': 'cpp',
+    '.cxx': 'cpp',
+    '.hpp': 'cpp',
+    '.hxx': 'cpp',
+    // C#
+    '.cs': 'csharp',
+    // Ruby
+    '.rb': 'ruby',
+    '.rake': 'ruby',
+    // PHP
+    '.php': 'php',
+    // Swift
+    '.swift': 'swift',
+    // Shell
+    '.sh': 'shell',
+    '.bash': 'shell',
+    '.zsh': 'shell',
+    '.fish': 'shell',
+    // Web
+    '.html': 'html',
+    '.htm': 'html',
+    '.css': 'css',
+    '.scss': 'scss',
+    '.sass': 'sass',
+    '.less': 'less',
+    '.vue': 'vue',
+    '.svelte': 'svelte',
+    // Data / Config
+    '.json': 'json',
+    '.jsonc': 'json',
+    '.yaml': 'yaml',
+    '.yml': 'yaml',
+    '.toml': 'toml',
+    '.xml': 'xml',
+    '.graphql': 'graphql',
+    '.gql': 'graphql',
+    // Docs
+    '.md': 'markdown',
+    '.mdx': 'markdown',
+    '.rst': 'restructuredtext',
+    '.tex': 'latex',
+    // Other
+    '.lua': 'lua',
+    '.r': 'r',
+    '.R': 'r',
+    '.dart': 'dart',
+    '.ex': 'elixir',
+    '.exs': 'elixir',
+    '.erl': 'erlang',
+    '.hrl': 'erlang',
+    '.hs': 'haskell',
+    '.clj': 'clojure',
+    '.tf': 'terraform',
+    '.proto': 'protobuf',
+    '.sql': 'sql',
 };
 export function shouldExclude(repoPath, config) {
     const normalizedPath = normalizeRepoPath(repoPath);
@@ -16,7 +91,7 @@ export function shouldExclude(repoPath, config) {
 export function buildFastGlobIgnore(exclude) {
     const patterns = new Set();
     for (const pattern of exclude) {
-        const normalized = normalizeRepoPath(pattern).replace(/\/$/, "");
+        const normalized = normalizeRepoPath(pattern).replace(/\/$/, '');
         if (!normalized) {
             continue;
         }
@@ -32,50 +107,63 @@ export function buildFastGlobIgnore(exclude) {
     }
     return [...patterns];
 }
+export async function readGitignorePatterns(rootPath) {
+    try {
+        const raw = await readFile(path.join(rootPath, '.gitignore'), 'utf8');
+        return raw
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0 && !line.startsWith('#') && !line.startsWith('!'));
+    }
+    catch {
+        return [];
+    }
+}
 export function detectLanguage(filePath) {
-    return LANGUAGE_BY_EXTENSION[path.extname(filePath)] ?? "unknown";
+    return LANGUAGE_BY_EXTENSION[path.extname(filePath)] ?? 'unknown';
 }
 export function isPreciseLanguage(filePath, config) {
     return config.languages.precise.includes(path.extname(filePath));
 }
 function matchesExcludePattern(repoPath, pattern) {
-    const normalized = normalizeRepoPath(pattern).replace(/\/$/, "");
+    const normalized = normalizeRepoPath(pattern).replace(/\/$/, '');
     if (!normalized) {
         return false;
     }
     if (hasGlob(normalized)) {
-        return globToRegExp(normalized).test(repoPath) || globToRegExp(`**/${normalized}`).test(repoPath);
+        return (globToRegExp(normalized).test(repoPath) ||
+            globToRegExp(`**/${normalized}`).test(repoPath));
     }
     if (repoPath === normalized || repoPath.startsWith(`${normalized}/`)) {
         return true;
     }
-    if (!normalized.includes("/")) {
-        return repoPath.split("/").includes(normalized);
+    if (!normalized.includes('/')) {
+        return repoPath.split('/').includes(normalized);
     }
     return false;
 }
 function normalizeRepoPath(value) {
-    return value.replace(/\\/g, "/").replace(/^\.\/+/, "");
+    return value.replace(/\\/g, '/').replace(/^\.\/+/, '');
 }
 function hasGlob(pattern) {
     return /[*?[\]{}]/.test(pattern);
 }
 function globToRegExp(pattern) {
-    let source = "";
+    let source = '';
     for (let index = 0; index < pattern.length; index += 1) {
         const char = pattern[index];
         const next = pattern[index + 1];
-        if (char === "*" && next === "*") {
-            source += ".*";
+        if (char === '*' && next === '*') {
+            source += '.*';
             index += 1;
             continue;
         }
-        if (char === "*") {
-            source += "[^/]*";
+        if (char === '*') {
+            source += '[^/]*';
             continue;
         }
-        if (char === "?") {
-            source += "[^/]";
+        if (char === '?') {
+            source += '[^/]';
             continue;
         }
         source += escapeRegExp(char);
@@ -83,5 +171,5 @@ function globToRegExp(pattern) {
     return new RegExp(`^${source}$`);
 }
 function escapeRegExp(value) {
-    return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+    return value.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
 }

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

@@ -1,3 +1,3 @@
-import type { KGraphConfig } from "../types/config.js";
-import type { ScanResult } from "../types/maps.js";
+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

@@ -1,16 +1,19 @@
-import { readFile, stat } from "node:fs/promises";
-import crypto from "node:crypto";
-import path from "node:path";
-import fg from "fast-glob";
-import { buildFastGlobIgnore, detectLanguage, isPreciseLanguage, shouldExclude } from "./file-classifier.js";
-import { extractTsSymbols } from "./ts-symbol-extractor.js";
+import fg from 'fast-glob';
+import crypto from 'node:crypto';
+import { readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { buildFastGlobIgnore, detectLanguage, isPreciseLanguage, readGitignorePatterns, shouldExclude, } from './file-classifier.js';
+import { extractTsSymbols } from './ts-symbol-extractor.js';
 export async function scanRepository(rootPath, config, previous) {
+    const gitignorePatterns = await readGitignorePatterns(rootPath);
+    const allExcludes = [...config.exclude, ...gitignorePatterns];
+    const mergedConfig = { ...config, exclude: allExcludes };
     const entries = await fg(config.include, {
         cwd: rootPath,
         dot: true,
         onlyFiles: true,
         unique: true,
-        ignore: buildFastGlobIgnore(config.exclude)
+        ignore: buildFastGlobIgnore(allExcludes),
     });
     const files = [];
     const symbols = [];
@@ -18,14 +21,20 @@ export async function scanRepository(rootPath, config, previous) {
     const relationships = [];
     const warnings = [];
     for (const repoPath of entries.sort()) {
-        if (shouldExclude(repoPath, config)) {
+        if (shouldExclude(repoPath, mergedConfig)) {
             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 [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,
@@ -34,8 +43,8 @@ export async function scanRepository(rootPath, config, previous) {
                 sizeBytes: info.size,
                 modifiedAt: info.mtime.toISOString(),
                 contentHash,
-                scanStatus: isPreciseLanguage(repoPath, config) ? "mapped" : "generic",
-                warnings: []
+                scanStatus: isPreciseLanguage(repoPath, config) ? 'mapped' : 'generic',
+                warnings: [],
             };
             if (isPreciseLanguage(repoPath, config)) {
                 const extracted = extractTsSymbols(text, repoPath);
@@ -55,9 +64,9 @@ export async function scanRepository(rootPath, config, previous) {
                 extension: path.extname(repoPath),
                 language: detectLanguage(repoPath),
                 sizeBytes: 0,
-                contentHash: "",
-                scanStatus: "failed",
-                warnings: [message]
+                contentHash: '',
+                scanStatus: 'failed',
+                warnings: [message],
             });
         }
     }
@@ -66,18 +75,22 @@ export async function scanRepository(rootPath, config, previous) {
 }
 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 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)) {
+        if (previous &&
+            previous.path !== file.path &&
+            !currentPaths.has(previous.path)) {
             relationships.push({
-                sourceType: "file",
+                sourceType: 'file',
                 sourceId: file.path,
-                targetType: "file",
+                targetType: 'file',
                 targetId: previous.path,
-                relationshipType: "moved-from",
-                confidence: "high"
+                relationshipType: 'moved-from',
+                confidence: 'high',
             });
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kentwynn/kgraph",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Persistent repo intelligence for AI coding assistants.",
   "type": "module",
   "bin": {
@@ -14,6 +14,7 @@
   "scripts": {
     "clean": "node scripts/clean-dist.mjs",
     "build": "npm run clean && tsc -p tsconfig.json",
+    "postbuild": "chmod +x dist/cli/index.js",
     "test": "vitest run",
     "kgraph": "tsx src/cli/index.ts",
     "check:artifacts": "node scripts/check-clean-artifacts.mjs",