dsh-plugin-codegraph-tree-sitter 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CC ZHAO
+
+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,17 @@
+# dsh-plugin-codegraph-tree-sitter
+
+Self-built code-graph indexer. Parses TypeScript, TSX, JavaScript, JSX, Python, and Go with `web-tree-sitter` and writes schema version 4 to `.codegraph/codegraph.db`, so a workspace needs no external indexer. Registers only an indexer, never a store.
+
+Part of **[dsh-plugin-codegraph](https://github.com/CC19990113/dsh-plugin-codegraph)** — structural code intelligence for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness).
+
+Most users should install the bundle instead, which mounts this package and its siblings in one layer:
+
+```sh
+dsh plugin --profile <name> add dsh-plugin-codegraph
+```
+
+See the [project README](https://github.com/CC19990113/dsh-plugin-codegraph#readme) for setup, configuration, and the full tool reference.
+
+## License
+
+[MIT](LICENSE)

package/lib/extract.d.ts

@@ -0,0 +1,70 @@
+/**
+ * One-file extraction: walk a parsed tree exactly once, collecting the definitions, call sites, and
+ * import bindings the two-pass resolver in `resolve.ts` needs.
+ *
+ * The caller of a call node is the nearest enclosing definition, or the file itself when the call sits
+ * at module top level — the on-disk format records it that way, and a third of the call edges in a
+ * real workspace are of exactly this shape.
+ * @module dsh-plugin-codegraph-tree-sitter/extract
+ */
+import type { Tree } from 'web-tree-sitter';
+import type { LanguageSpec } from './languages.ts';
+/** One declaration this file introduces, before cross-file resolution. */
+export interface RawDefinition {
+    /** Stable position-derived key, unique within the file. */
+    readonly key: string;
+    /** The immediately enclosing definition's {@link key}, or `null` for a module-top-level definition. */
+    readonly parentKey: string | null;
+    readonly kind: string;
+    readonly name: string;
+    /** Enclosing definition names, outermost first; used to build `qualifiedName`. */
+    readonly container: readonly string[];
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly startColumn: number;
+    readonly endColumn: number;
+    readonly isExported: boolean;
+    readonly isAsync: boolean;
+    readonly isStatic: boolean;
+}
+/** One call site this file contains, before callee resolution. */
+export interface RawCall {
+    /** The calling definition's {@link RawDefinition.key}, or `null` for a module-top-level call. */
+    readonly callerKey: string | null;
+    /** The callee's simple name, e.g. `parse` from `parse(x)` or `obj.parse(x)`. */
+    readonly calleeName: string;
+    readonly line: number;
+    readonly column: number;
+    /**
+     * Whether the callee expression is a member access (`obj.parse()`) rather than a bare identifier
+     * (`parse()`). With no type information, a member call's receiver could be anything, so a name
+     * match against it is far less trustworthy than a bare identifier's — `resolve.ts` uses this to
+     * separate that noise from a genuine gap in the graph when a call goes unresolved.
+     */
+    readonly isMemberCall: boolean;
+}
+/** One import binding this file introduces. */
+export interface RawImport {
+    /** The name this file's scope binds, after any `as` rename. */
+    readonly localName: string;
+    /** The name as declared in the source module, `'default'` for a default import, or `'*'` for a
+     * namespace or whole-package import — the latter two never drive resolution but are recorded for
+     * completeness. */
+    readonly importedName: string;
+    /** The raw module specifier text, e.g. `./bar` or `fmt`. */
+    readonly specifier: string;
+}
+/** Everything one file's walk produced. */
+export interface FileExtraction {
+    readonly definitions: RawDefinition[];
+    readonly calls: RawCall[];
+    readonly imports: RawImport[];
+}
+/**
+ * Extract every definition, call, and import from one parsed file.
+ * @param tree - the file's parsed syntax tree.
+ * @param spec - the language's extraction table entry.
+ * @returns the raw, not-yet-resolved extraction.
+ */
+export declare function extractFile(tree: Tree, spec: LanguageSpec): FileExtraction;
+//# sourceMappingURL=extract.d.ts.map

package/lib/extract.js

@@ -0,0 +1,296 @@
+/**
+ * One-file extraction: walk a parsed tree exactly once, collecting the definitions, call sites, and
+ * import bindings the two-pass resolver in `resolve.ts` needs.
+ *
+ * The caller of a call node is the nearest enclosing definition, or the file itself when the call sits
+ * at module top level — the on-disk format records it that way, and a third of the call edges in a
+ * real workspace are of exactly this shape.
+ * @module dsh-plugin-codegraph-tree-sitter/extract
+ */
+/** A node's named children, with the `null` slots `web-tree-sitter` reserves for missing nodes dropped. */
+function namedChildren(node) {
+    return node.namedChildren.filter(child => child !== null);
+}
+/** Every descendant of `node` matching `types`, with `null` slots dropped. */
+function descendantsOfType(node, types) {
+    return node.descendantsOfType([...types]).filter(child => child !== null);
+}
+/**
+ * A field's text, or `fallback` when the field is absent. `childForFieldName` is typed to return
+ * `Node | null` for any field name on any node, but a specific field is absent only when the caller
+ * asks for one the matched node type does not carry.
+ * @param node - the node to read a field from.
+ * @param field - the field name.
+ * @param fallback - the text to use when the field is absent.
+ * @returns the field's text, or `fallback`.
+ */
+function fieldText(node, field, fallback) {
+    return node.childForFieldName(field)?.text ?? fallback;
+}
+/** Whether a node carries a modifier keyword as one of its own (non-named) children. */
+function hasKeywordChild(node, keyword) {
+    for (let index = 0; index < node.childCount; index++) {
+        const child = node.child(index);
+        if (child !== null && !child.isNamed && child.text === keyword)
+            return true;
+    }
+    return false;
+}
+/** The definition rule matching `node`, or `undefined` when it introduces no declaration. */
+function matchDefinition(node, definitions) {
+    for (const rule of definitions) {
+        if (node.type !== rule.nodeType)
+            continue;
+        if (rule.value !== undefined) {
+            const value = node.childForFieldName(rule.value.field);
+            if (value === null || !rule.value.types.includes(value.type))
+                continue;
+        }
+        return rule;
+    }
+    return undefined;
+}
+/**
+ * The callee's simple name from a call node's function-field expression: the identifier itself, or
+ * the rightmost property/field/selector name for a member access — `obj.parse()` resolves against
+ * `parse`, the same ambiguity a workspace-wide name search already accepts and reports through
+ * `unresolvedCount` when it cannot be settled.
+ * @param callee - the call node's function-field expression.
+ * @returns the simple name, or `undefined` when the expression names nothing identifier-shaped (a
+ * computed or parenthesized callee, for instance).
+ */
+function calleeName(callee) {
+    if (callee.type === 'identifier')
+        return callee.text;
+    const property = callee.childForFieldName('property')
+        ?? callee.childForFieldName('field')
+        ?? callee.childForFieldName('attribute');
+    if (property !== null && property.type !== 'computed_property_name')
+        return property.text;
+    return undefined;
+}
+/** ECMAScript-family import extraction: `import_statement` with a `import_clause` and a `source`. */
+function ecmascriptImports(node) {
+    // `source` is required by the grammar; the null case only satisfies `childForFieldName`'s general
+    // `Node | null` return type.
+    const source = node.childForFieldName('source');
+    /* v8 ignore next */
+    if (source === null)
+        return [];
+    // An empty string literal (`import ''`) parses with no `string_fragment` child.
+    const specifier = namedChildren(source)[0]?.text ?? source.text.slice(1, -1);
+    // A side-effect-only import (`import './side'`) carries no `import_clause`.
+    const clause = namedChildren(node).find(child => child.type === 'import_clause');
+    if (clause === undefined)
+        return [];
+    const imports = [];
+    for (const child of namedChildren(clause)) {
+        if (child.type === 'identifier') {
+            imports.push({ localName: child.text, importedName: 'default', specifier });
+        }
+        if (child.type === 'namespace_import') {
+            // The grammar requires `* as <identifier>` together; a `namespace_import` node is never
+            // produced with no named child.
+            const local = namedChildren(child)[0];
+            /* v8 ignore next */
+            if (local === undefined)
+                continue;
+            imports.push({ localName: local.text, importedName: '*', specifier });
+        }
+        if (child.type !== 'named_imports')
+            continue;
+        // The grammar allows only `import_specifier` as a `named_imports` child; `{}` produces zero
+        // named children, never one of a different type.
+        for (const specifierNode of namedChildren(child)) {
+            /* v8 ignore next */
+            if (specifierNode.type !== 'import_specifier')
+                continue;
+            // `name` is required by the grammar; only `alias` is conditional on an `as` clause.
+            const name = specifierNode.childForFieldName('name');
+            const alias = specifierNode.childForFieldName('alias');
+            /* v8 ignore next */
+            if (name === null)
+                continue;
+            imports.push({ localName: alias?.text ?? name.text, importedName: name.text, specifier });
+        }
+    }
+    return imports;
+}
+/**
+ * One `dotted_name` or `aliased_import` child of a Python import statement, resolved to a binding.
+ * @param child - the `dotted_name` or `aliased_import` node.
+ * @param bindsSymbol - whether this statement binds one module-level name (`from x import y`) rather
+ * than the whole module (`import x`), which decides whether the binding's `importedName` is the
+ * declared name or the seam's namespace marker `'*'`.
+ * @param specifier - the module specifier this binding resolves against.
+ * @returns the resolved import binding.
+ */
+function pythonBinding(child, bindsSymbol, specifier) {
+    const name = child.type === 'aliased_import' ? fieldText(child, 'name', child.text) : child.text;
+    const local = child.type === 'aliased_import' ? fieldText(child, 'alias', name) : name;
+    return { localName: local, importedName: bindsSymbol ? name : '*', specifier };
+}
+/** Python import extraction: `import_statement` (bare) and `import_from_statement` (relative-capable). */
+function pythonImports(node) {
+    if (node.type === 'import_statement') {
+        return namedChildren(node)
+            .filter(child => child.type === 'dotted_name' || child.type === 'aliased_import')
+            .map((child) => {
+            const name = child.type === 'aliased_import' ? fieldText(child, 'name', child.text) : child.text;
+            return pythonBinding(child, false, name);
+        });
+    }
+    // `module_name` is required by the grammar's `import_from_statement` rule, including the dots-only
+    // form (`from . import x`); the null case only satisfies `childForFieldName`'s general return type.
+    const moduleNode = node.childForFieldName('module_name');
+    /* v8 ignore next */
+    const specifier = moduleNode?.text ?? '';
+    return namedChildren(node)
+        // The module node itself is a named child alongside the imported names — excluded by identity,
+        // not by node type, because an absolute module specifier is a `dotted_name` too, indistinguishable
+        // by type from an imported symbol written the same way (`from x import y`).
+        .filter(child => !(moduleNode !== null && child.equals(moduleNode)))
+        .filter(child => child.type === 'dotted_name' || child.type === 'aliased_import' || child.type === 'wildcard_import')
+        .flatMap((child) => {
+        if (child.type === 'wildcard_import')
+            return [];
+        return [pythonBinding(child, true, specifier)];
+    });
+}
+/** Go import extraction: `import_declaration` wraps one or more `import_spec` nodes, each requiring a `path`. */
+function goImports(node) {
+    return descendantsOfType(node, ['import_spec']).map((spec) => {
+        // `path` is required by the grammar's `import_spec` rule; the null case only satisfies
+        // `childForFieldName`'s general `Node | null` return type.
+        const path = spec.childForFieldName('path');
+        /* v8 ignore next */
+        const raw = path === null ? '' : (namedChildren(path)[0]?.text ?? path.text.slice(1, -1));
+        // `String.prototype.split` always returns at least one element, so `.pop()` is never `undefined`;
+        // the fallback only satisfies the general array-access return type.
+        /* v8 ignore next */
+        const local = fieldText(spec, 'name', raw.split('/').pop() ?? raw);
+        // A package import binds no individual symbol; resolution never matches on `importedName: '*'`,
+        // but recording the binding still lets `status`-adjacent tooling see what a file imports.
+        return { localName: local, importedName: '*', specifier: raw };
+    });
+}
+/**
+ * Extract every definition, call, and import from one parsed file.
+ * @param tree - the file's parsed syntax tree.
+ * @param spec - the language's extraction table entry.
+ * @returns the raw, not-yet-resolved extraction.
+ */
+export function extractFile(tree, spec) {
+    const definitions = [];
+    const calls = [];
+    const imports = [];
+    const containerNames = [];
+    const containerKeys = [null];
+    function visit(node) {
+        const rule = matchDefinition(node, spec.definitions);
+        if (rule !== undefined) {
+            const nameNode = node.childForFieldName(rule.nameField);
+            // A matched rule's node type is always the NAMED-declaration form the grammar mandates a name
+            // for; the anonymous form (`function_expression`, `class` as an expression, both produced by an
+            // anonymous default export) parses as a different node type this rule never matches.
+            /* v8 ignore next */
+            if (nameNode !== null) {
+                const key = `${node.startPosition.row}:${node.startPosition.column}`;
+                const parentKey = containerKeys[containerKeys.length - 1] ?? null;
+                definitions.push({
+                    key,
+                    parentKey,
+                    kind: rule.kind,
+                    name: nameNode.text,
+                    container: [...containerNames],
+                    startLine: node.startPosition.row + 1,
+                    endLine: node.endPosition.row + 1,
+                    startColumn: node.startPosition.column,
+                    endColumn: node.endPosition.column,
+                    isExported: isExported(node, spec.language, nameNode.text),
+                    isAsync: hasKeywordChild(node, 'async'),
+                    isStatic: hasKeywordChild(node, 'static'),
+                });
+                containerNames.push(nameNode.text);
+                containerKeys.push(key);
+                for (const child of namedChildren(node))
+                    visit(child);
+                containerKeys.pop();
+                containerNames.pop();
+                return;
+            }
+        }
+        if (spec.callTypes.includes(node.type)) {
+            // Every call-shaped node type in every language table entry requires its callee field; the null
+            // case only satisfies `childForFieldName`'s general return type.
+            const callee = node.childForFieldName(spec.callFunctionField);
+            /* v8 ignore next */
+            const name = callee === null ? undefined : calleeName(callee);
+            if (name !== undefined) {
+                calls.push({
+                    callerKey: containerKeys[containerKeys.length - 1] ?? null,
+                    calleeName: name,
+                    line: node.startPosition.row + 1,
+                    column: node.startPosition.column,
+                    // `callee` is non-null whenever `name` is: the optional chaining only satisfies the type
+                    // system's view of the field lookup above, not a real possibility here.
+                    /* v8 ignore next */
+                    isMemberCall: callee?.type !== 'identifier',
+                });
+            }
+        }
+        if (spec.importTypes.includes(node.type)) {
+            imports.push(...extractImports(node, spec.language));
+        }
+        for (const child of namedChildren(node))
+            visit(child);
+    }
+    visit(tree.rootNode);
+    return { definitions, calls, imports };
+}
+/** Dispatch import extraction to the language family that owns `node`'s syntax. */
+function extractImports(node, language) {
+    switch (language) {
+        case 'typescript':
+        case 'tsx':
+        case 'javascript':
+        case 'jsx':
+            return ecmascriptImports(node);
+        case 'python':
+            return pythonImports(node);
+        case 'go':
+            return goImports(node);
+        /* v8 ignore next 2 -- exhaustive over LANGUAGE_TABLE's current language labels; unreachable. */
+        default:
+            return [];
+    }
+}
+/**
+ * Whether a declaration is exported from its module, by the export construct its own language
+ * defines: ECMAScript wraps an exported statement in `export_statement`; Go's spec defines an
+ * exported identifier as one starting with an uppercase letter, with no separate keyword; Python
+ * defines no export construct at all, so every Python declaration reports `false` rather than guess
+ * one from a naming convention or an `__all__` list the extractor does not read.
+ * @param node - the definition node.
+ * @param language - the seam language label the file was parsed as.
+ * @param name - the declaration's simple name.
+ * @returns whether the language's own export rule marks this declaration exported.
+ */
+function isExported(node, language, name) {
+    if (language === 'go')
+        return /^\p{Lu}/u.test(name);
+    if (language === 'python')
+        return false;
+    let current = node.parent;
+    while (current !== null) {
+        if (current.type === 'export_statement')
+            return true;
+        // A statement block or class body ends the search: an export wraps a top-level statement, never
+        // reaches inside a function or class body to a nested declaration.
+        if (current.type === 'statement_block' || current.type === 'class_body')
+            return false;
+        current = current.parent;
+    }
+    return false;
+}
+//# sourceMappingURL=extract.js.map

package/lib/git-hooks.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Git hooks as an opt-in alternative to live file watching: a caller who wants a reindex to follow
+ * `git checkout`/`merge`/`commit`/`rebase` rather than (or in addition to) every individual file edit
+ * can install a hook that runs one command after each.
+ *
+ * Deliberately just a library function, never wired into plugin load or exposed as a model-visible
+ * tool: `.git/hooks/*` is shared, ambient state that outlives this plugin and can collide with a
+ * user's other tooling (husky, lint-staged, ...) — installing it automatically, or letting a model
+ * decide to install it, is a materially bigger blast radius than the `.codegraph/` cache this package
+ * otherwise owns outright. A caller wires this in deliberately, from their own init script.
+ *
+ * Resolving *which* `hooksDir` to use — including the "worktrees share one hooks directory" case — is
+ * the caller's job, composed from {@link detectWorktree} in `worktree.ts`; this module only ever
+ * touches the one directory path it is given.
+ * @module dsh-plugin-codegraph-tree-sitter/git-hooks
+ */
+/** Marks the start of this package's block inside a hook script. */
+export declare const HOOK_MARKER_BEGIN = "# >>> dsh-plugin-codegraph sync >>>";
+/** Marks the end of this package's block inside a hook script. */
+export declare const HOOK_MARKER_END = "# <<< dsh-plugin-codegraph sync <<<";
+/** Where hooks live, and what to run once installed there. */
+export interface GitHooksOptions {
+    /** Absolute path to the git hooks directory (typically `<repo>/.git/hooks`). */
+    readonly hooksDir: string;
+    /** Shell command to run from each installed hook, verbatim. */
+    readonly command: string;
+}
+/**
+ * Install `options.command` into every hook in {@link HOOK_NAMES} under `options.hooksDir`.
+ *
+ * A hook that does not exist yet is created fresh (`#!/bin/sh` plus the marker block) and made
+ * executable. A hook that already exists keeps its own content: a prior install's marker block is
+ * replaced in place (idempotent re-install, e.g. after `command` changes), otherwise the block is
+ * appended after whatever the file already contains — this package never discards another tool's hook.
+ * @param options - the hooks directory and the command to install.
+ * @returns the hook names now carrying this package's block (whether newly created or pre-existing).
+ */
+export declare function installGitHooks(options: GitHooksOptions): Promise<{
+    installed: readonly string[];
+}>;
+/**
+ * Remove this package's marker block from every hook under `options.hooksDir`, leaving the rest of
+ * each file (another tool's hook content, or a user's own) untouched. A hook that does not exist, or
+ * exists but was never installed by {@link installGitHooks}, is left alone entirely — this never
+ * deletes a hook file outright, even one that becomes empty once the block is removed.
+ * @param options - the hooks directory to clean up.
+ * @returns the hook names this package's block was actually removed from.
+ */
+export declare function uninstallGitHooks(options: Pick<GitHooksOptions, 'hooksDir'>): Promise<{
+    removed: readonly string[];
+}>;
+//# sourceMappingURL=git-hooks.d.ts.map

package/lib/git-hooks.js

@@ -0,0 +1,75 @@
+/**
+ * Git hooks as an opt-in alternative to live file watching: a caller who wants a reindex to follow
+ * `git checkout`/`merge`/`commit`/`rebase` rather than (or in addition to) every individual file edit
+ * can install a hook that runs one command after each.
+ *
+ * Deliberately just a library function, never wired into plugin load or exposed as a model-visible
+ * tool: `.git/hooks/*` is shared, ambient state that outlives this plugin and can collide with a
+ * user's other tooling (husky, lint-staged, ...) — installing it automatically, or letting a model
+ * decide to install it, is a materially bigger blast radius than the `.codegraph/` cache this package
+ * otherwise owns outright. A caller wires this in deliberately, from their own init script.
+ *
+ * Resolving *which* `hooksDir` to use — including the "worktrees share one hooks directory" case — is
+ * the caller's job, composed from {@link detectWorktree} in `worktree.ts`; this module only ever
+ * touches the one directory path it is given.
+ * @module dsh-plugin-codegraph-tree-sitter/git-hooks
+ */
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+/** Marks the start of this package's block inside a hook script. */
+export const HOOK_MARKER_BEGIN = '# >>> dsh-plugin-codegraph sync >>>';
+/** Marks the end of this package's block inside a hook script. */
+export const HOOK_MARKER_END = '# <<< dsh-plugin-codegraph sync <<<';
+/** The git hook names this module installs into: every point a working tree can change via git. */
+const HOOK_NAMES = ['post-checkout', 'post-merge', 'post-commit', 'post-rewrite'];
+/** Matches this package's own marker block (and one adjacent blank line) anywhere in a hook script. */
+const MARKER_BLOCK = new RegExp(`\\n?${HOOK_MARKER_BEGIN}[\\s\\S]*?${HOOK_MARKER_END}\\n?`);
+/**
+ * Install `options.command` into every hook in {@link HOOK_NAMES} under `options.hooksDir`.
+ *
+ * A hook that does not exist yet is created fresh (`#!/bin/sh` plus the marker block) and made
+ * executable. A hook that already exists keeps its own content: a prior install's marker block is
+ * replaced in place (idempotent re-install, e.g. after `command` changes), otherwise the block is
+ * appended after whatever the file already contains — this package never discards another tool's hook.
+ * @param options - the hooks directory and the command to install.
+ * @returns the hook names now carrying this package's block (whether newly created or pre-existing).
+ */
+export async function installGitHooks(options) {
+    await mkdir(options.hooksDir, { recursive: true });
+    const block = `${HOOK_MARKER_BEGIN}\n${options.command}\n${HOOK_MARKER_END}\n`;
+    const installed = [];
+    for (const hookName of HOOK_NAMES) {
+        const path = join(options.hooksDir, hookName);
+        const existing = await readFile(path, 'utf8').catch(() => undefined);
+        const content = existing === undefined
+            ? `#!/bin/sh\n${block}`
+            : MARKER_BLOCK.test(existing)
+                ? existing.replace(MARKER_BLOCK, `\n${block}`)
+                : `${existing.endsWith('\n') ? existing : `${existing}\n`}${block}`;
+        await writeFile(path, content, 'utf8');
+        await chmod(path, 0o755);
+        installed.push(hookName);
+    }
+    return { installed };
+}
+/**
+ * Remove this package's marker block from every hook under `options.hooksDir`, leaving the rest of
+ * each file (another tool's hook content, or a user's own) untouched. A hook that does not exist, or
+ * exists but was never installed by {@link installGitHooks}, is left alone entirely — this never
+ * deletes a hook file outright, even one that becomes empty once the block is removed.
+ * @param options - the hooks directory to clean up.
+ * @returns the hook names this package's block was actually removed from.
+ */
+export async function uninstallGitHooks(options) {
+    const removed = [];
+    for (const hookName of HOOK_NAMES) {
+        const path = join(options.hooksDir, hookName);
+        const existing = await readFile(path, 'utf8').catch(() => undefined);
+        if (existing === undefined || !MARKER_BLOCK.test(existing))
+            continue;
+        await writeFile(path, existing.replace(MARKER_BLOCK, ''), 'utf8');
+        removed.push(hookName);
+    }
+    return { removed };
+}
+//# sourceMappingURL=git-hooks.js.map

package/lib/gitignore.d.ts

@@ -0,0 +1,58 @@
+/**
+ * A deliberately small subset of `.gitignore` pattern syntax, just enough to keep the indexer's
+ * exclusion set in step with what a project's own build tooling already hides from version control —
+ * without a new dependency on a full gitignore-matching library.
+ *
+ * Only the project root's `.gitignore` is read; per-directory `.gitignore` files nested below it are
+ * not consulted, matching the walk's own root-relative worldview.
+ *
+ * Supported:
+ *  - Blank lines and lines starting with `#` are comments.
+ *  - A leading `!` negates: a later matching rule re-includes a path an earlier rule excluded.
+ *  - A pattern containing `/` (leading or internal) is anchored to the project root; one with no `/`
+ *    at all matches at any depth, by basename.
+ *  - A trailing `/` restricts the rule to directories.
+ *  - `*` matches any run of characters other than `/`, within one path segment.
+ *
+ * Not supported. Each is treated as a literal character (or, for `**`, as two literal `*` globs),
+ * which only ever makes a pattern *more* specific than a real gitignore would — it degrades toward
+ * "excludes nothing extra" rather than toward "excludes too much":
+ *  - `**` (explicit multi-segment wildcards — plain unanchored patterns already cross depths)
+ *  - character classes (`[abc]`), `?`, and backslash escapes
+ *  - git's rule that a negation cannot resurrect a path inside an already-excluded directory: here,
+ *    a negation re-includes whatever it matches regardless of ancestor exclusions.
+ * @module dsh-plugin-codegraph-tree-sitter/gitignore
+ */
+/** One parsed `.gitignore` rule, pre-compiled to a matcher. */
+export interface GitignoreRule {
+    /** Matches a full project-relative, `/`-separated path. */
+    readonly pattern: RegExp;
+    /** `!`-prefixed: a match re-includes rather than excludes. */
+    readonly negated: boolean;
+    /** Trailing-`/`: only ever matches a directory. */
+    readonly directoryOnly: boolean;
+}
+/**
+ * Parse `.gitignore` file content into an ordered rule list.
+ * @param content - the raw file text.
+ * @returns rules in file order. Matching must apply them in order and keep the last match, per
+ *   git's own precedence — a later line overrides an earlier one it conflicts with.
+ */
+export declare function parseGitignore(content: string): GitignoreRule[];
+/**
+ * Whether `relativePath` should be excluded per `rules`. Later rules win over earlier ones, matching
+ * git's own precedence: the loop keeps applying matches rather than stopping at the first one.
+ * @param rules - parsed rules, in file order.
+ * @param relativePath - the path to test, relative to the project root, `/`-separated.
+ * @param isDirectory - whether the path names a directory; directory-only rules skip files.
+ * @returns whether the path is excluded.
+ */
+export declare function matchesGitignore(rules: readonly GitignoreRule[], relativePath: string, isDirectory: boolean): boolean;
+/**
+ * Load and parse `<projectRoot>/.gitignore`.
+ * @param projectRoot - absolute path of the project root.
+ * @returns the parsed rules, or an empty array when there is no root `.gitignore` — a missing file
+ *   means "nothing extra to exclude," not a failure, so this never throws.
+ */
+export declare function loadGitignore(projectRoot: string): Promise<GitignoreRule[]>;
+//# sourceMappingURL=gitignore.d.ts.map