opencode-rag-plugin 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Christoph Döllinger
+
+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,423 @@
+# OpenCodeRAG
+
+Local-first RAG plugin for OpenCode — semantic code search powered by
+embeddings and vector similarity.
+
+**Note: This is an early pre-release and may not work correctly in all cases.
+  If you find bugs, please create an issue.**
+
+## Features
+
+- **AST-aware chunking** — splits code into functions, classes, methods using
+  tree-sitter for 16 languages, plus regex-based chunking for 4 markup/config/doc
+  formats (Markdown, Razor, .sln, LaTeX). Falls back to line-based chunking for
+  unrecognized formats.
+- **Incremental indexing** — manifest-backed indexing skips unchanged files,
+  removes deleted entries, and updates only changed files.
+- **Watch mode** — `index --watch` re-indexes on file changes with debounced,
+  serialized passes.
+- **Pluggable chunkers** — add custom language chunkers via config or programmatic API.
+- **Configurable embeddings** — Ollama (default) or OpenAI-compatible providers.
+  Batch embedding with configurable batch size.
+- **Local vector store** — LanceDB with L2 distance scoring, memory mode for
+  testing.
+- **CLI** — index, query, clear, status commands.
+- **OpenCode plugin** — exposes a chunk retrieval tool and suggests relevant files after each user message via the `chat.message` hook.
+
+## Architecture
+
+```
+Workspace Files
+       │
+       ▼
+┌──────────────┐
+│   Chunker    │  AST-based (tree-sitter) or line-based fallback
+└──────┬───────┘
+       │ chunks
+       ▼
+┌──────────────┐
+│   Embedder   │  Ollama / OpenAI-compatible API
+└──────┬───────┘
+       │ vectors
+       ▼
+┌──────────────┐
+│  VectorStore │  LanceDB (local files or memory:// for tests)
+└──────┬───────┘
+       │ + manifest.json
+       ▼
+┌──────────────┐
+│ Indexer/Retr.│  incremental index or query/search
+└──────┬───────┘
+       │ results
+       ▼
+   LLM Context
+```
+
+## Tech Stack
+
+| Layer       | Technology                                          |
+| ----------- | --------------------------------------------------- |
+| Runtime     | Node.js v22 + tsx (ESM)                             |
+| Language    | TypeScript 5.8                                      |
+| Chunking    | web-tree-sitter (WASM) + tree-sitter-wasm grammars  |
+| Embeddings  | Ollama / OpenAI-compatible (native fetch)           |
+| Vector DB   | LanceDB (`@lancedb/lancedb`)                        |
+| CLI         | commander                                           |
+| Tests       | Node built-in test runner (`node --test`)           |
+| Package mgr | npm (with `--legacy-peer-deps`)                     |
+
+## Installation
+
+```bash
+git clone <repo-url>
+cd OpenCodeRAG
+npm install --legacy-peer-deps
+```
+
+### Dependencies
+
+- **Node.js v22+** for native ESM and fetch support
+- **apache-arrow** — peer dependency for LanceDB (auto-installed)
+- **tree-sitter-wasm** — ships pre-built WASM grammars for all supported languages
+
+## Configuration
+
+Create `opencode-rag.json` in the project root (auto-detected) or pass via
+`--config`. The repository's own [`opencode-rag.json`](./opencode-rag.json) serves
+as a complete example with all available options.
+
+Config files support partial overrides — missing keys fall back to defaults.
+Deep merging is applied per section.
+
+### Embedding Providers
+
+| Provider | `baseUrl` example                 | Notes                        |
+| -------- | --------------------------------- | ---------------------------- |
+| ollama   | `http://localhost:11434/api`      | Default. No apiKey required. Proxy is disabled when `embedding.proxy.url` is empty. |
+| openai   | `https://api.openai.com/v1`       | Requires apiKey.             |
+
+`embedding.timeoutMs` defaults to 30000 ms. Increase it if your local model has a slow cold start.
+
+OpenAI provider sends all texts in a single request. Ollama sends one request
+per request to `/api/embed`. Set `embedding.proxy.url` to use the standard
+proxy-aware HTTP path instead of the direct socket path.
+
+## Usage
+
+This extension consists of two main interfaces:
+1. **CLI** — for manual indexing and querying from the terminal
+2. **OpenCode plugin** — for automatic retrieval and file suggestions within the chat interface
+
+### CLI
+
+```bash
+# Index the workspace incrementally
+npx tsx src/cli.ts index
+
+# Force full re-index (clears existing data first)
+npx tsx src/cli.ts index --force
+
+# Watch workspace and incrementally re-index on changes
+npx tsx src/cli.ts index --watch
+
+# Semantic search
+npx tsx src/cli.ts query "How is authentication handled?"
+
+# Limit results
+npx tsx src/cli.ts query "error handling" --top-k 5
+
+# Show indexing stats
+npx tsx src/cli.ts status
+
+# Example output:
+#   Indexed chunks:    1247
+#   Store path:        /home/user/project/.opencode/rag_db
+#   Embedding provider: ollama
+#   Embedding model:   nomic-embed-text
+#   Manifest status:   ok
+#   Manifest entries:  42
+#   Last indexed:      2026-05-28 10:45:02
+#   Up-to-date files:  42
+#   Pending files:     0
+#   Watch mode:        off
+
+# Clear all indexed data
+npx tsx src/cli.ts clear
+
+# Use custom config
+npx tsx src/cli.ts index --config ./my-config.json
+```
+
+`index` is incremental by default. A sidecar manifest is stored at
+`<vectorStore.path>/manifest.json` and tracks file hashes, chunk counts, and the
+last successful index timestamp. If the manifest is missing or corrupt while the
+vector store already contains data, the next index pass clears and rebuilds the
+store to avoid duplicates.
+
+### Watch workflow
+
+Start a watch session:
+
+```bash
+npx tsx src/cli.ts index --watch
+```
+
+The initial pass indexes the workspace, then watches for file changes. On each
+`add`, `change`, `unlink`, or `unlinkDir` event, the watch debounces (300 ms)
+and triggers a new incremental pass. If a pass is already running, the re-index
+queues one follow-up pass and runs it as soon as the current pass finishes.
+
+The watcher ignores excluded directories, the vector store path, and the
+manifest file itself. Press `Ctrl+C` to stop.
+
+### OpenCode Plugin
+
+The plugin registers:
+
+1. **`opencode-rag-context`** — a custom retrieval tool for chunk-level evidence
+2. **`chat.message`** — after each user message, automatically retrieves relevant indexed files and appends a compact suggestion list to the message text
+
+#### Chat Message File Suggestions
+
+After you send a message, the plugin:
+1. Extracts the user's message text
+2. Runs semantic retrieval against the indexed workspace
+3. Groups results by file, sorts by best chunk score, and formats a compact file list:
+   ```
+   src/plugin.ts (typescript, lines 10-42)
+   src/core/config.ts (typescript, lines 66-145)
+   ```
+4. Appends the list (max 10 files) to your message text
+
+Only file paths, language, and line ranges are shown — no scores or code snippets. This gives the agent lightweight hints about which files are relevant without inflating the context window.
+
+**Config:**
+
+| Option | Default | Description |
+| ------ | ------- | ----------- |
+| `openCode.overrideRead` | `false` | Set to `true` to restore the legacy RAG-backed `read` tool (deprecated) |
+| `openCode.maxContextChunks` | `5` | Maximum chunks per retrieval (affects `opencode-rag-context` tool output) |
+| `retrieval.topK` | `10` | Number of chunks fetched per query (controls chat.message file suggestion breadth) |
+
+Errors during retrieval are silently caught — a failed search won't break the
+chat.
+
+#### Install from source
+
+After cloning and installing dependencies:
+
+```bash
+# Option 1: Use the project-local auto-loaded plugin
+# The repo already includes .opencode/plugins/rag-plugin.ts
+
+# Option 2: Build and install via npm pack
+npm run build
+npm pack
+opencode plugin .\opencode-rag-0.1.0.tgz
+
+# Option 3: Install from npm (once published)
+opencode plugin opencode-rag
+```
+
+The plugin auto-detects configuration from `opencode-rag.json` or
+`.opencode/rag.json` in the project root.
+
+If you use the project-local plugin file, OpenCode auto-loads it from
+`.opencode/plugins/` at startup and no `plugin` entry is required in
+`.opencode/opencode.json`.
+
+Restart OpenCode after changing plugin files or plugin configuration.
+
+### Logging
+
+Logging is configured under the `logging` key:
+
+```json
+{
+  "logging": {
+    "level": "info",
+    "logFilePath": "./.opencode/opencode-rag.log"
+  }
+}
+```
+
+| Option       | Default                        | Description                                  |
+| ------------ | ------------------------------ | -------------------------------------------- |
+| `level`      | `"info"`                       | Log level: `"debug"`, `"info"`, or `"error"` |
+| `logFilePath` | `"./.opencode/opencode-rag.log"` | Path to the log file (relative paths are resolved against the workspace directory) |
+
+The resolved log file path also falls back to the `LOG_FILE_PATH` environment variable when the config value is not set. Config takes precedence over the env var when both are provided.
+
+#### AGENTS.md hints for using the plugin
+
+Add a section like this to the target workspace's `AGENTS.md` so the agent
+knows how to use the plugin correctly:
+
+```markdown
+## OpenCodeRAG Plugin
+
+This workspace has OpenCodeRAG installed for semantic code retrieval.
+
+### `opencode-rag-context` tool
+Before planning, editing, or answering, use this tool to retrieve relevant code
+chunks with file paths, line ranges, and surrounding implementation.
+- `query` (required) — narrow, specific search, e.g. `"authentication middleware setup"`
+- `pathHints` (optional) — up to 10 path filters, e.g. `["src/auth/"]`
+- `languageHints` (optional) — up to 10 language filters, e.g. `["typescript"]`
+- `topK` (optional) — result count (1-25, default 10)
+
+### File suggestions
+After each user message, a `chat.message` hook appends up to 10 relevant file
+suggestions to the message. Look for lines like
+`src/file.ts (typescript, lines 10-42)` at the bottom of user input.
+
+### Indexing
+- The plugin auto-indexes changed files in the background (debounced 5s)
+- If no results come back, the workspace may not be indexed yet —
+  run `opencode-rag index` from the terminal
+- Tiny files (under 1 KB), excluded extensions, and excluded directories
+  (`node_modules`, `.git`, `.opencode`, `dist`, etc.) are silently skipped
+```
+
+The plugin registers itself in the system prompt via the
+`experimental.chat.system.transform` hook, so compliant agents will see a
+reminder about the `opencode-rag-context` tool in their system instructions.
+
+## Data Model
+
+```typescript
+interface Chunk {
+  id: string;
+  content: string;
+  embedding?: number[];
+  metadata: {
+    filePath: string;
+    startLine: number;
+    endLine: number;
+    language: string;
+  };
+}
+
+interface SearchResult {
+  chunk: Chunk;
+  score: number;   // 1 / (1 + L2_distance), range [0, 1]
+}
+```
+
+## Chunking
+
+| Language   | Strategy                       | Captures                                  |
+| ---------- | ------------------------------ | ----------------------------------------- |
+| TypeScript | AST (tree-sitter)              | functions, methods, classes, interfaces   |
+| Python     | AST (tree-sitter)              | functions, classes, decorated definitions |
+| Java       | AST (tree-sitter)              | methods, classes, interfaces, enums       |
+| Go         | AST (tree-sitter)              | functions, methods, type declarations     |
+| C          | AST (tree-sitter)              | functions, structs, enums, unions, typedefs |
+| C++        | AST (tree-sitter)              | functions, classes, structs, enums, namespaces, templates |
+| C#         | AST (tree-sitter)              | classes, interfaces, structs, enums, methods, namespaces, records |
+| JavaScript | AST (tree-sitter)              | functions, classes, arrow functions, exports |
+| JSON       | AST (tree-sitter)              | key-value pairs                           |
+| XML        | AST (tree-sitter)              | elements (1 chunk per root element)       |
+| HTML       | AST (tree-sitter)              | `<script>` / `<style>` blocks             |
+| CSS        | AST (tree-sitter)              | rule sets, at-rules, media, keyframes     |
+| Razor      | Regex (brace matching)         | `@code` / `@functions` blocks, template regions |
+| Markdown   | Regex heading split            | h1/h2 sections + trailing content         |
+| Solution   | Regex (section boundary)       | project entries and global sections       |
+| Rust       | AST (tree-sitter)              | functions, structs, enums, traits, impl blocks, modules, types |
+| Ruby       | AST (tree-sitter)              | methods, classes, modules, singleton methods |
+| Kotlin     | AST (tree-sitter)              | functions, classes, interfaces, objects, properties |
+| Swift      | AST (tree-sitter)              | functions, classes, structs, enums, protocols, extensions, variables |
+| LaTeX      | Regex section split            | chapter/section/subsection/subsubsection boundaries |
+| PDF        | Paragraph-based (text extraction) | groups small paragraphs, splits oversized |
+| (other)    | Line-based (100 lines/chunk)   | raw text blocks                           |
+
+Custom chunkers can be added without modifying the project source code. Two
+registration paths are supported:
+
+### Config file
+
+Add a `chunkers` array to `opencode-rag.json`:
+
+```json
+{
+  "chunkers": [
+    { "module": "./path/to/rust-chunker.js", "extensions": [".rs"] }
+  ]
+}
+```
+
+The module path is resolved relative to the config file. The loaded module must
+export (as default or named) an object implementing the `Chunker` interface:
+
+```typescript
+interface Chunker {
+  readonly language: string;
+  readonly fileExtensions?: string[];
+  chunk(filePath: string, content: string): Promise<Chunk[]>;
+}
+```
+
+### Programmatic
+
+```typescript
+import { registerChunker } from "opencode-rag/library";
+registerChunker(myChunker, [".rs"]);
+```
+
+The optional second argument overrides the chunker's `fileExtensions`. If a
+built-in chunker already covers the requested extension, the new registration is
+skipped and a warning is emitted.
+
+## Vector Store
+
+LanceDB stores chunks in a `chunks` table with columns: `id`, `content`,
+`embedding` (vector), `filePath`, `startLine`, `endLine`, `language`.
+
+- **Disk mode**: files in `vectorStore.path` (default `.opencode/rag_db`)
+- **Memory mode**: `memory://` URI — for tests only, data lost on close
+- **Manifest sidecar**: `manifest.json` in the store directory tracks indexed
+  files for incremental updates
+- Schema is auto-inferred from a seed row on first table creation
+- L2 distance search, score = `1 / (1 + distance)`
+- Stored file paths are normalized to absolute forward-slash paths
+
+## Development
+
+```bash
+# TypeScript typecheck
+npm run typecheck
+
+# Run all tests
+npm test
+
+# Run specific test file
+node --import tsx --test src/__tests__/chunker/fallback.test.ts
+```
+
+Project structure:
+```
+  src/
+    core/          — interfaces.ts, config.ts
+    chunker/       — grammar.ts, base.ts, language chunkers, fallback.ts, factory.ts, uuid.ts
+    embedder/      — ollama.ts, openai.ts, factory.ts
+    vectorstore/   — lancedb.ts
+    retriever/     — retriever.ts
+    types/         — opencode-plugin.d.ts
+    indexer.ts     — incremental indexing + watch scheduling
+    watcher.ts     — background indexer (chokidar + debounced scheduler + periodic timer)
+    cli.ts, plugin.ts, plugin-entry.ts, index.ts
+    __tests__/     — mirrors the module structure
+```
+
+Test framework is Node's built-in runner (`node:test`) with `tsx` for TypeScript
+imports. No test library dependencies.
+
+## Limitations
+
+- Embedding model dimension is auto-probed at startup; falls back to 384 if probing fails.
+- 21 built-in chunkers (AST for 16, regex for 4, PDF text for 1) + configurable fallback
+
+## Privacy
+
+All processing is local. Embeddings are generated via local Ollama by default.
+No data leaves the machine unless configured to use a remote embedding API.

package/dist/chunker/base.d.ts

@@ -0,0 +1,10 @@
+import type { Chunker, Chunk } from "../core/interfaces.js";
+export declare abstract class TreeSitterChunker implements Chunker {
+    abstract readonly language: string;
+    abstract readonly fileExtensions: string[];
+    abstract readonly grammarName: string;
+    abstract readonly nodeTypes: Set<string>;
+    private parser;
+    private getParser;
+    chunk(filePath: string, content: string): Promise<Chunk[]>;
+}

package/dist/chunker/base.js

@@ -0,0 +1,34 @@
+import { Parser } from "web-tree-sitter";
+import { loadLanguage, walkTree } from "./grammar.js";
+import { uuid } from "./uuid.js";
+export class TreeSitterChunker {
+    parser = null;
+    async getParser() {
+        if (!this.parser) {
+            const lang = await loadLanguage(this.grammarName);
+            this.parser = new Parser();
+            this.parser.setLanguage(lang);
+        }
+        return this.parser;
+    }
+    async chunk(filePath, content) {
+        if (content.trim().length === 0)
+            return [];
+        const parser = await this.getParser();
+        const tree = parser.parse(content);
+        if (!tree)
+            return [];
+        const nodes = walkTree(tree.rootNode, this.nodeTypes, content);
+        return nodes.map((node) => ({
+            id: uuid(),
+            content: node.text,
+            metadata: {
+                filePath,
+                startLine: node.startLine,
+                endLine: node.endLine,
+                language: this.language,
+            },
+        }));
+    }
+}
+//# sourceMappingURL=base.js.map

package/dist/chunker/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sourceRoot":"","sources":["../../src/chunker/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAgB,MAAM,cAAc,CAAC;AAEpE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,MAAM,OAAgB,iBAAiB;IAM7B,MAAM,GAAkB,IAAI,CAAC;IAE7B,KAAK,CAAC,SAAS;QACrB,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,MAAM,IAAI,GAAG,MAAM,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAClD,IAAI,CAAC,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;YAC3B,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QAChC,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,QAAgB,EAAE,OAAe;QAC3C,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,EAAE,CAAC;QAE3C,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QACtC,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACnC,IAAI,CAAC,IAAI;YAAE,OAAO,EAAE,CAAC;QAErB,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QAE/D,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAa,EAAE,EAAE,CAAC,CAAC;YACnC,EAAE,EAAE,IAAI,EAAE;YACV,OAAO,EAAE,IAAI,CAAC,IAAI;YAClB,QAAQ,EAAE;gBACR,QAAQ;gBACR,SAAS,EAAE,IAAI,CAAC,SAAS;gBACzB,OAAO,EAAE,IAAI,CAAC,OAAO;gBACrB,QAAQ,EAAE,IAAI,CAAC,QAAQ;aACxB;SACF,CAAC,CAAC,CAAC;IACN,CAAC;CACF"}

package/dist/chunker/c.d.ts

@@ -0,0 +1,8 @@
+import { TreeSitterChunker } from "./base.js";
+export declare class CChunker extends TreeSitterChunker {
+    readonly language = "c";
+    readonly fileExtensions: string[];
+    readonly grammarName = "c";
+    readonly nodeTypes: Set<string>;
+}
+export declare const cChunker: CChunker;

package/dist/chunker/c.js

@@ -0,0 +1,16 @@
+import { TreeSitterChunker } from "./base.js";
+export class CChunker extends TreeSitterChunker {
+    language = "c";
+    fileExtensions = [".c", ".h"];
+    grammarName = "c";
+    nodeTypes = new Set([
+        "function_definition",
+        "struct_specifier",
+        "enum_specifier",
+        "union_specifier",
+        "type_definition",
+        "preproc_def",
+    ]);
+}
+export const cChunker = new CChunker();
+//# sourceMappingURL=c.js.map

package/dist/chunker/c.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"c.js","sourceRoot":"","sources":["../../src/chunker/c.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C,MAAM,OAAO,QAAS,SAAQ,iBAAiB;IACpC,QAAQ,GAAG,GAAG,CAAC;IACf,cAAc,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC9B,WAAW,GAAG,GAAG,CAAC;IAClB,SAAS,GAAG,IAAI,GAAG,CAAC;QAC3B,qBAAqB;QACrB,kBAAkB;QAClB,gBAAgB;QAChB,iBAAiB;QACjB,iBAAiB;QACjB,aAAa;KACd,CAAC,CAAC;CACJ;AAED,MAAM,CAAC,MAAM,QAAQ,GAAG,IAAI,QAAQ,EAAE,CAAC"}

package/dist/chunker/cpp.d.ts

@@ -0,0 +1,8 @@
+import { TreeSitterChunker } from "./base.js";
+export declare class CppChunker extends TreeSitterChunker {
+    readonly language = "cpp";
+    readonly fileExtensions: string[];
+    readonly grammarName = "cpp";
+    readonly nodeTypes: Set<string>;
+}
+export declare const cppChunker: CppChunker;

package/dist/chunker/cpp.js

@@ -0,0 +1,17 @@
+import { TreeSitterChunker } from "./base.js";
+export class CppChunker extends TreeSitterChunker {
+    language = "cpp";
+    fileExtensions = [".cpp", ".cc", ".cxx", ".hpp", ".hxx"];
+    grammarName = "cpp";
+    nodeTypes = new Set([
+        "function_definition",
+        "class_specifier",
+        "struct_specifier",
+        "enum_specifier",
+        "union_specifier",
+        "namespace_definition",
+        "template_declaration",
+    ]);
+}
+export const cppChunker = new CppChunker();
+//# sourceMappingURL=cpp.js.map

package/dist/chunker/cpp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cpp.js","sourceRoot":"","sources":["../../src/chunker/cpp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C,MAAM,OAAO,UAAW,SAAQ,iBAAiB;IACtC,QAAQ,GAAG,KAAK,CAAC;IACjB,cAAc,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACzD,WAAW,GAAG,KAAK,CAAC;IACpB,SAAS,GAAG,IAAI,GAAG,CAAC;QAC3B,qBAAqB;QACrB,iBAAiB;QACjB,kBAAkB;QAClB,gBAAgB;QAChB,iBAAiB;QACjB,sBAAsB;QACtB,sBAAsB;KACvB,CAAC,CAAC;CACJ;AAED,MAAM,CAAC,MAAM,UAAU,GAAG,IAAI,UAAU,EAAE,CAAC"}

package/dist/chunker/csharp.d.ts

@@ -0,0 +1,8 @@
+import { TreeSitterChunker } from "./base.js";
+export declare class CSharpChunker extends TreeSitterChunker {
+    readonly language = "csharp";
+    readonly fileExtensions: string[];
+    readonly grammarName = "c_sharp";
+    readonly nodeTypes: Set<string>;
+}
+export declare const csharpChunker: CSharpChunker;

package/dist/chunker/csharp.js

@@ -0,0 +1,17 @@
+import { TreeSitterChunker } from "./base.js";
+export class CSharpChunker extends TreeSitterChunker {
+    language = "csharp";
+    fileExtensions = [".cs"];
+    grammarName = "c_sharp";
+    nodeTypes = new Set([
+        "class_declaration",
+        "interface_declaration",
+        "struct_declaration",
+        "enum_declaration",
+        "method_declaration",
+        "namespace_declaration",
+        "record_declaration",
+    ]);
+}
+export const csharpChunker = new CSharpChunker();
+//# sourceMappingURL=csharp.js.map

package/dist/chunker/csharp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"csharp.js","sourceRoot":"","sources":["../../src/chunker/csharp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C,MAAM,OAAO,aAAc,SAAQ,iBAAiB;IACzC,QAAQ,GAAG,QAAQ,CAAC;IACpB,cAAc,GAAG,CAAC,KAAK,CAAC,CAAC;IACzB,WAAW,GAAG,SAAS,CAAC;IACxB,SAAS,GAAG,IAAI,GAAG,CAAC;QAC3B,mBAAmB;QACnB,uBAAuB;QACvB,oBAAoB;QACpB,kBAAkB;QAClB,oBAAoB;QACpB,uBAAuB;QACvB,oBAAoB;KACrB,CAAC,CAAC;CACJ;AAED,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,aAAa,EAAE,CAAC"}

package/dist/chunker/css.d.ts

@@ -0,0 +1,8 @@
+import { TreeSitterChunker } from "./base.js";
+export declare class CssChunker extends TreeSitterChunker {
+    readonly language = "css";
+    readonly fileExtensions: string[];
+    readonly grammarName = "css";
+    readonly nodeTypes: Set<string>;
+}
+export declare const cssChunker: CssChunker;

package/dist/chunker/css.js

@@ -0,0 +1,14 @@
+import { TreeSitterChunker } from "./base.js";
+export class CssChunker extends TreeSitterChunker {
+    language = "css";
+    fileExtensions = [".css"];
+    grammarName = "css";
+    nodeTypes = new Set([
+        "rule_set",
+        "at_rule",
+        "media_statement",
+        "keyframes_statement",
+    ]);
+}
+export const cssChunker = new CssChunker();
+//# sourceMappingURL=css.js.map

package/dist/chunker/css.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"css.js","sourceRoot":"","sources":["../../src/chunker/css.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C,MAAM,OAAO,UAAW,SAAQ,iBAAiB;IACtC,QAAQ,GAAG,KAAK,CAAC;IACjB,cAAc,GAAG,CAAC,MAAM,CAAC,CAAC;IAC1B,WAAW,GAAG,KAAK,CAAC;IACpB,SAAS,GAAG,IAAI,GAAG,CAAC;QAC3B,UAAU;QACV,SAAS;QACT,iBAAiB;QACjB,qBAAqB;KACtB,CAAC,CAAC;CACJ;AAED,MAAM,CAAC,MAAM,UAAU,GAAG,IAAI,UAAU,EAAE,CAAC"}

package/dist/chunker/factory.d.ts

@@ -0,0 +1,27 @@
+import type { Chunker, Chunk } from "../core/interfaces.js";
+import { typescriptChunker } from "./typescript.js";
+import { pythonChunker } from "./python.js";
+import { javaChunker } from "./java.js";
+import { goChunker } from "./go.js";
+import { markdownChunker } from "./markdown.js";
+import { cChunker } from "./c.js";
+import { cppChunker } from "./cpp.js";
+import { csharpChunker } from "./csharp.js";
+import { javascriptChunker } from "./javascript.js";
+import { razorChunker } from "./razor.js";
+import { jsonChunker } from "./json.js";
+import { htmlChunker } from "./html.js";
+import { cssChunker } from "./css.js";
+import { xmlChunker } from "./xml.js";
+import { slnChunker } from "./sln.js";
+import { rustChunker } from "./rust.js";
+import { rubyChunker } from "./ruby.js";
+import { kotlinChunker } from "./kotlin.js";
+import { swiftChunker } from "./swift.js";
+import { texChunker } from "./tex.js";
+import { fallbackChunker } from "./fallback.js";
+import { pdfChunker } from "./pdf.js";
+export declare function registerChunker(chunker: Chunker, extensions?: string[]): void;
+export declare function getChunker(filePath: string): Chunker;
+export declare function chunkFile(filePath: string, content: string): Promise<Chunk[]>;
+export { typescriptChunker, pythonChunker, javaChunker, goChunker, markdownChunker, cChunker, cppChunker, csharpChunker, javascriptChunker, razorChunker, jsonChunker, htmlChunker, cssChunker, xmlChunker, slnChunker, rustChunker, rubyChunker, kotlinChunker, swiftChunker, texChunker, pdfChunker, fallbackChunker };