xindex 1.0.0

package/.claude/settings.local.json

@@ -0,0 +1,73 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(chmod +x:*)",
+      "Bash(./bin/xindex.index)",
+      "Bash(./bin/xindex.search)",
+      "Bash(npx tsx:*)",
+      "Bash(./bin/xindex-index)",
+      "Bash(./bin/xindex-search)",
+      "Bash(./bin/xindex-index:*)",
+      "Bash(./bin/xindex-search build components:*)",
+      "Bash(node:*)",
+      "Bash(./bin/xindex-search embedding model neural network:*)",
+      "Bash(./bin/xindex-search natural language processing keywords:*)",
+      "Bash(./bin/xindex-search vector database storage:*)",
+      "Bash(./bin/xindex-search file indexing pipeline:*)",
+      "Bash(./bin/xindex-search \"embedding model neural network\")",
+      "Bash(./bin/xindex-search \"natural language processing keywords\")",
+      "Bash(./bin/xindex-search \"vector database storage\")",
+      "Bash(./bin/xindex-search \"file indexing pipeline\")",
+      "Bash(./bin/xindex-search \"search query results\")",
+      "Bash(./bin/xindex-search \"embedding model\")",
+      "Bash(./bin/xindex-search \"natural language keywords\")",
+      "Bash(time ./bin/xindex-search embedding:*)",
+      "Bash(time ./bin/xindex-search \"stream batch processing\")",
+      "WebSearch",
+      "WebFetch(domain:github.com)",
+      "WebFetch(domain:www.npmjs.com)",
+      "Bash(npm install:*)",
+      "Bash(./bin/xindex-search \"embedding\")",
+      "mcp__xindex__xindex_search",
+      "mcp__xindex__xindex_index",
+      "Bash(grep -r \"IIndexRecord\\\\|IIndexStats\\\\|keywords.*join\\\\|metadata\" /Users/slava/project/xindex/componets/index/*.ts)",
+      "mcp__xindex__xindex_reset",
+      "Bash(xargs cat:*)",
+      "Bash(npx tsc:*)",
+      "Bash(npx:*)",
+      "Bash(node_modules/.bin/tsc --noEmit)",
+      "Bash(./node_modules/.bin/tsc --noEmit)",
+      "Bash(grep:*)",
+      "Bash(./bin/xindex-reset:*)",
+      "Bash(bin/xindex-search hey:*)",
+      "Bash(bin/xindex-search \"test\")",
+      "Bash(bin/xindex-index .:*)",
+      "Bash(bin/xindex-search search index:*)",
+      "Bash(bin/xindex-search stream:*)",
+      "Bash(bin/xindex-search nonexistent_xyz:*)",
+      "Bash(timeout 25 bash -c ':*)",
+      "Bash(node_modules/.bin/tsx --version)",
+      "Bash(node_modules/.bin/tsx --eval \"import './apps/mcpApp.js'\")",
+      "Bash(node_modules/.bin/tsx --eval \"import './apps/mcpApp.ts'\")",
+      "Bash(node_modules/.bin/tsx --eval \"import './apps/run.mcp.ts'\")",
+      "Bash(node_modules/.bin/tsx --eval \"import './apps/mcpApp.ts'; import './apps/watchApp.ts'; import './apps/indexApp.ts'; import './componets/indexFileContent.ts'\")",
+      "Bash(node_modules/.bin/tsx --eval \"import './componets/handleFileEvent.ts'; import './componets/indexFileContent.ts'; import './apps/watchApp.ts'; import './apps/indexApp.ts'\")",
+      "Bash(find /Users/slava/project/xindex/.xindex/objects -name \"*.json\" -exec grep -l '\"type\":\"meta\"' {} \\\\;)",
+      "Bash(find /Users/slava/project/xindex/.xindex/objects -name \"*.json\" -exec grep -l '\"type\":\"cluster\"' {} \\\\;)",
+      "Bash(find /Users/slava/project/xindex/.xindex/objects -name \"*.json\" -exec grep -l '\"type\":\"manifest\"' {} \\\\;)",
+      "Bash(read f:*)",
+      "Bash(python3 -c ':*)",
+      "Bash(wc -l /Users/slava/project/xindex/componets/index/*.ts)",
+      "Bash(yarn search:*)",
+      "Bash(npm run *)",
+      "Skill(with-cursor)",
+      "Bash(git mv *)",
+      "Bash(./bin/xindex-search \"where is MCP server\")",
+      "Bash(xindex-search where *)"
+    ]
+  },
+  "enableAllProjectMcpServers": true,
+  "enabledMcpjsonServers": [
+    "xindex"
+  ]
+}

package/.claude/skills/make-hof/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: make-hof
+description: Refactors a function/module to the HOF component pattern, or creates a new HOF from a description. Use when converting plain functions to factory + instance pattern.
+argument-hint: "[file or description]"
+---
+Refactor or create HOF component: $ARGUMENTS
+
+Read [playbook.md](playbook.md) for full instructions, then follow them.

package/.claude/skills/make-hof/playbook.md

@@ -0,0 +1,38 @@
+## Pattern
+
+HOF component = factory function that returns a configured function instance.
+
+```ts
+// 1. Type — named I<Name>, describes the returned function signature
+export type IDoThing = (a: string, b: number) => Promise<string>;
+
+// 2. Factory — PascalCase, takes config, returns typed function
+export function DoThing(config: Config): IDoThing {
+    return async function doThing(a, b) { /* uses config */ }
+}
+
+// Caller constructs their own:
+// const doThing = DoThing(myConfig);
+```
+
+Exports: `IDoThing` (type), `DoThing` (factory). No default instance — callers configure at point of use.
+
+## Steps
+
+1. **Read** the target file (or understand the description if creating new)
+2. **Identify** what becomes config — values that are currently hardcoded, passed at init time, or vary between use cases
+3. **Apply pattern**:
+   - Extract `type I<Name>` for the inner function signature
+   - Wrap in `function <Name>(config): I<Name>` factory
+   - Move hardcoded values to factory params
+   - Inner function uses closure over factory params
+4. **Preserve** module-level init (e.g. `await pipeline(...)`) outside the factory — these are singletons
+5. **Refactor callers** — find all imports of the old function, replace with factory import + local construction (`const fn = Factory(config)`)
+
+## Rules
+
+- Keep module-level side effects (model loading, index creation) outside the factory
+- Factory params should be the minimal set that varies — don't over-parameterize
+- Inner function name = camelCase of factory name
+- If the file has multiple related functions, group under one factory only if they share config
+- Use specific types over `string` when possible (e.g. union types for known values)

package/.cursor/mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "xindex": {
+      "command": "xindex-mcp",
+      "args": []
+    }
+  }
+}

package/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "xindex": {
+      "command": "xindex-mcp",
+      "args": []
+    }
+  }
+}

package/.xindex.json

@@ -0,0 +1,22 @@
+{
+  "ignoreKeywords": [
+    "import", "export", "const", "function", "return", "async", "await", "type", "string", "number",
+    "from", "default", "let", "var",
+    "if", "else", "switch", "case", "break", "continue",
+    "for", "of", "in",
+    "try", "catch", "finally", "throw",
+    "new", "delete", "as", "is", "typeof", "instanceof", "void",
+    "this", "super",
+    "interface", "class", "extends", "implements",
+    "public", "private", "protected", "static", "abstract", "readonly",
+    "declare", "namespace", "module", "enum",
+    "boolean", "any", "unknown", "never",
+    "undefined", "null", "object",
+    "record", "array", "readonlyarray", "promise",
+    "true", "false",
+    "src", "packages", "fun", "componets", "streamx", "apps", "run", "rnd", "tsx",
+    "utf8", "length", "map", "slice", "push", "join", "resolve", "stringify",
+    "json", "settimeout", "path", "readfile"
+  ],
+  "ignoreFiles": ["rnd/**", ".xindex"]
+}

package/CLAUDE.md

@@ -0,0 +1,54 @@
+# CLAUDE.md
+
+## Shorthand
+
+- **NxM** — N parts × M sub-parts, title + 1 sentence each. Include text diagrams when M ≥ 3. E.g., `3x3` = 3 parts × 3 sub-parts
+- **NxMxD** — same as NxM but D sentences per sub-part. E.g., `3x3x2` = 3×3 with 2 sentences each
+- **Nxx** — N parts, title + 1 sentence each (no sub-parts). E.g., `3xx`
+- **unpack** — 3-5 parts × 3-5 sub-parts with text diagrams
+- **Text diagrams** — ASCII flows, hierarchies, tables. Keep minimal.
+- **research/search/ground** — search the Internet using DuckDuckGo MCP
+- **plan dev / go / dev / implement** — start implementation → triggers Pre-implementation check
+- **recover** — find most recent `task.*.md` in `.ai/task/` (by date+mtime, exclude `*.log.md`/`*.report.md`), summarize state and next steps
+- **pull details / expand / flesh out** — enrich task with full detail while preserving shape (see Detail expansion)
+
+
+## Task Management
+
+- **Location**: `.ai/task/`. Naming: `task.<yyyy-mm-dd>-<slug>.md` (date = creation date, slug includes roadmap number when applicable)
+- **Structure**: Context (why + links) → Goal → Diagram → Steps (NxM plan). Default: text diagram + 3x3 plan; scale up only if complexity demands it
+- **Diagram ↔ Steps consistency**: must always reflect each other. Update both in the same pass. Inconsistency = bug.
+- **Task kickoff**: user provides notes → create task file + log → notes into Context → draft Goal + structure → ask 3–5 clarifying questions (`[MUST]` = blocker, `[SHOULD]` = design risk) → iterate until MUSTs resolved, SHOULDs answered or defaulted → finalize with diagram + steps
+- **Pre-implementation**: reread task → identify gaps → research (parallel agents for independent questions) → verify diagram ↔ steps → ask user if changes are significant → identify parallel tracks → start
+- **Post-implementation**: recheck task vs actual code. Mark completed steps, note deviations, sync diagram. Drift = bug.
+- **Logs**: `task.<...slug>.log.md` alongside task. Format: `### <date>` + bullets. Log decisions, blockers, outcomes, deviations — sufficient to reconstruct context. Parallel agents get own logs: `task.<...slug>.track-<name>.log.md`; merge outcomes back to main log.
+- **Log splitting**: at ~500+ lines, split into `task.<...slug>.1.log.md`, `*.2.log.md`, etc. Original becomes index. Use bash `sed -n` for extraction.
+- **Reports**: `task.<...slug>.report.md` — consolidates research findings after completion
+- **Section splitting**: large `.md` files → `*.1.*`, `*.2.*` parts. Original becomes index with bullet summaries.
+- **Detail expansion**: reread task → research every step (files, APIs, deps) → expand with concrete details (paths, functions, tables, exact changes) → preserve NxM shape → no info loss → update diagram → keep balanced detail density
+- **Context recovery**: when chat compacts, reread active task's log to recover direction
+- **Completed tasks**: move done tasks (+ their logs, maps, reports) to `.ai/task/done/`. Update `done/INDEX.md` (relative links, newest-first). Root `INDEX.md` lists only active/pending tasks + a link to `done/INDEX.md`.
+
+## Code Patterns
+
+- **HOF component** — factory function that returns a configured function instance. Export only the factory (`DoThing`) and type (`IDoThing`). Callers construct their own instance — no default export.
+  ```ts
+  export type IDoThing = (a: string, b: number) => Promise<string>;
+  export function DoThing(config: Config): IDoThing {
+      return async function doThing(a, b) { ... }
+  }
+  // caller: const doThing = DoThing({dep1, dep2});
+  ```
+- **HOF dependencies** — when a factory depends on other components, pass them as a destructured object: `DoThing({embed, index}: {embed: IEmbed, index: LocalIndex})`. This makes dependencies explicit and order-independent.
+- **Tagged union** — use `IType<{type: string, ...}>` from `componets/IType.ts` for discriminated unions. Each variant gets a `type` literal, the union is `|`-joined.
+  ```ts
+  export type IFileEvent =
+      | IType<{ type: "index", path: string }>
+      | IType<{ type: "remove", path: string }>;
+  ```
+- **Logger** — never use `console.log`/`console.error` directly in components or apps. Use `ILogger` from `componets/logger.ts`. Create at the `run.*` entry point level: `Logger(console.log)` for CLI apps, `Logger(console.error)` for MCP (stdout is the protocol channel). Inject as a dependency where needed.
+
+## Git Rules
+
+- **No Co-Authored-By** — never add `Co-Authored-By` lines to commit messages
+- **No tool-origin footers** — never add lines like `Made-with: Cursor`, `Generated with …`, or similar branding/attribution footers to commit messages, PR descriptions, or docs unless the user explicitly asks

package/README.md

@@ -0,0 +1,206 @@
+# xindex
+
+Local semantic code search. Index your codebase, search by meaning — no cloud, no API keys. Also runs as an MCP server so Claude Code (and other MCP clients) can search your repo directly.
+
+## Features
+
+- **Local** — everything runs on your machine; embeddings cached on disk
+- **Semantic search** — natural-language queries, not just substring match
+- **MCP server** — plug into Claude Code via `.mcp.json`
+- **Watch mode** — keep the index warm while you code
+- **Gitignore-aware** — respects `.gitignore` + custom ignore rules
+- **Zero config** — works with defaults; `.xindex.json` is optional
+
+## How it fits together
+
+```
+  your repo                      xindex
+  ─────────                      ──────
+  *.ts / *.md  ──►  walk  ──►  keywords  ──►  embed  ──►  .xindex/
+  .gitignore                                              (vectra index)
+                                                              ▲
+  CLI / MCP  ◄──  search  ◄──  embed query  ◄──  "question"  ┘
+```
+
+## Install
+
+```bash
+git clone <repo-url> xindex
+cd xindex
+yarn install        # or npm install
+npm link            # makes xindex-* binaries + xindex-mcp available on PATH
+```
+
+Requires Node.js. First run downloads the embedding model (`all-MiniLM-L6-v2`, ~25MB) — after that, fully offline.
+
+## Quick start
+
+```bash
+cd /path/to/your/project
+xindex-index .                         # build the index
+xindex-search "where is auth handled"  # ask a question
+```
+
+Index lives in `./.xindex/` — add it to `.gitignore`.
+
+## CLI
+
+All five binaries run from any directory; they index/search the current working directory.
+
+### `xindex-index [paths...]`
+Build or update the index. Defaults to `.` if no paths given.
+```bash
+xindex-index .
+xindex-index apps features
+```
+
+### `xindex-search <query...>`
+Search the index. All args are joined into one query. Default limit: 10.
+```bash
+xindex-search "database migration logic"
+xindex-search file watcher debounce
+```
+
+### `xindex-watch [paths...]`
+Initial index + filesystem watch for incremental updates. Uses a lock file so only one watcher owns updates at a time. Ctrl+C releases cleanly.
+```bash
+xindex-watch .
+```
+
+### `xindex-reset`
+Wipe and recreate the index. Destructive.
+```bash
+xindex-reset
+```
+
+### `xindex-mcp`
+Run as an MCP stdio server. Starts a background watcher by default.
+```bash
+xindex-mcp                   # with watch
+xindex-mcp --watch-disabled  # no watch
+xindex-mcp --watch-dir=./src # watch a specific dir
+```
+
+## MCP (Claude Code & others)
+
+Drop this into `.mcp.json` at your project root:
+
+```json
+{
+  "mcpServers": {
+    "xindex": {
+      "command": "xindex-mcp",
+      "args": []
+    }
+  }
+}
+```
+
+Requires `xindex-mcp` on PATH (`npm link` inside this repo does it). If you'd rather pin to an absolute path, use `/absolute/path/to/bin/xindex-mcp`.
+
+### Tools exposed
+
+| Tool | What it does | Input |
+|------|--------------|-------|
+| `xindex_search` | Semantic search | `query: string`, `limit?: number` (default 5, max 100) |
+| `xindex_index`  | Index paths | `inputs: string[]` (at least one) |
+| `xindex_reset`  | Wipe index (destructive) | — |
+
+Note: CLI `xindex-search` defaults to 10 results; MCP `xindex_search` defaults to 5.
+
+### Typical Claude Code flow
+
+1. Commit `.mcp.json` to your repo.
+2. Open the project in Claude Code — it picks up the xindex MCP server.
+3. Ask it to call `xindex_index` once with `inputs: ["."]`.
+4. From then on, it uses `xindex_search` for natural-language lookups.
+5. Watch mode keeps the index fresh as you edit.
+
+## Configuration
+
+### `.xindex.json` (optional)
+
+Place at your project root. Both fields are optional arrays; unknown keys are ignored.
+
+```json
+{
+  "ignoreKeywords": ["import", "export", "function", "const"],
+  "ignoreFiles": ["dist/**", "node_modules/**", ".xindex"]
+}
+```
+
+- **`ignoreKeywords`** — tokens stripped before embedding (noise words, language keywords, project slang). Keeps search focused on meaningful terms.
+- **`ignoreFiles`** — extra glob patterns excluded during walk/watch, on top of `.gitignore`.
+
+### `.xindex/` folder
+
+Created automatically. Contains:
+- `semantic/` — the vectra index (vectors + metadata)
+- `lock.json` — watcher lock (coordinates watch/MCP processes)
+
+**Always gitignore it.**
+
+### `.gitignore`
+
+Minimum:
+```
+.xindex
+node_modules/
+```
+
+## Examples
+
+### Index + search from the terminal
+
+```bash
+cd my-app
+xindex-index .
+xindex-search "rate limiter implementation"
+```
+
+### Keep the index warm while coding
+
+```bash
+xindex-watch .
+# edit files in another terminal; index updates incrementally
+# Ctrl+C to stop
+```
+
+### Use from Claude Code via MCP
+
+```bash
+# one-time setup
+cd xindex && npm link
+
+# in your project
+echo '{"mcpServers":{"xindex":{"command":"xindex-mcp","args":[]}}}' > .mcp.json
+
+# open project in Claude Code — xindex tools are available
+```
+
+### Run MCP without watching
+
+```bash
+xindex-mcp --watch-disabled
+```
+
+You control when reindexing happens via explicit `xindex_index` calls.
+
+## Project layout
+
+```
+apps/        entry points (run.*.ts) + app composers (IndexApp, SearchApp, McpApp, ...)
+bin/         shebang wrappers invoked by npm/yarn and .mcp.json
+componets/   shared building blocks: config, walk, watch, embed, vectra adapter, logger
+features/    domain operations: indexContent, searchIndex, removeContent, resetIndex
+packages/    small internal libs (streamx, fun)
+.xindex/     runtime data (gitignored)
+.xindex.json optional config
+.mcp.json    MCP registration for Claude Code / compatible clients
+```
+
+See [CLAUDE.md](CLAUDE.md) for contributor conventions (HOF pattern, logger rules, task workflow).
+
+## License
+
+MIT

package/apps/indexApp.ts

@@ -0,0 +1,31 @@
+import {readFile} from "fs/promises";
+import {from} from "../packages/streamx/src/from.js";
+import {map} from "../packages/streamx/src/map.js";
+import {tap} from "../packages/streamx/src/tap.js";
+import {run} from "../packages/streamx/src/index.js";
+import {IWalkFiles} from "../componets/walkFiles.js";
+import {IIndexContent} from "../features/indexContent.js";
+import {IRemoveContent} from "../features/removeContent.js";
+import {ILogger} from "../componets/logger.js";
+
+export type IIndexApp = (inputs: string[]) => Promise<void>;
+
+export function IndexApp({walkFiles, indexContent, removeContent, log}: {
+    walkFiles: IWalkFiles,
+    indexContent: IIndexContent,
+    removeContent: IRemoveContent,
+    log: ILogger,
+}): IIndexApp {
+    return async function indexApp(inputs) {
+        await run(
+            from(walkFiles(inputs))
+                .pipe(tap(id => log(`indexing: ${id}`)))
+                .pipe(map<string, string>(async (id) => {
+                    try { await removeContent(id); } catch (e) { log(`remove failed: ${id} — ${(e as any)?.message ?? e}`); }
+                    const text = await readFile(id, "utf8");
+                    await indexContent(id, `${text}. ${id}`);
+                    return id;
+                }))
+        );
+    }
+}

package/apps/mcpApp.ts

@@ -0,0 +1,119 @@
+import {McpServer} from "@modelcontextprotocol/sdk/server/mcp.js";
+import {StdioServerTransport} from "@modelcontextprotocol/sdk/server/stdio.js";
+import {z} from "zod";
+import {ISearchIndex} from "../features/searchIndex.js";
+import {IIndexApp} from "./indexApp.js";
+import {IGetIndexStats} from "../componets/index/getIndexStats.js";
+import {IResetIndex} from "../features/resetIndex.js";
+import {IWatchFiles} from "../componets/watchFiles.js";
+import {IHandleFileEvent} from "../componets/index/handleFileEvent.js";
+import {ILogger} from "../componets/logger.js";
+import {WatchFileEventsApp} from "./watchFileEventsApp.js";
+import {IWatcherLock} from "../componets/index/watcherLock.js";
+import {IXindexConfig} from "../componets/config/xindexConfig.js";
+import {FormatSearchResults} from "../componets/index/formatSearchResults.js";
+
+export type IMcpApp = () => Promise<void>;
+
+export type IMcpWatch = {
+    watchFiles: IWatchFiles,
+    watchDir: string,
+    handleFileEvent: IHandleFileEvent,
+    watcherLock: IWatcherLock,
+};
+
+export function McpApp({
+    searchContentIndex, indexApp, getIndexStats, resetIndex, log, watch, config,
+}: {
+    searchContentIndex: ISearchIndex,
+    indexApp: IIndexApp,
+    getIndexStats: IGetIndexStats,
+    resetIndex: IResetIndex,
+    log: ILogger,
+    watch?: IMcpWatch,
+    config: IXindexConfig,
+}): IMcpApp {
+    return async function mcpApp() {
+        const server = new McpServer({name: "xindex", version: "0.1.0"});
+
+        // --- search ---
+
+        server.registerTool("xindex_search", {
+            title: "Search codebase",
+            description: "Semantic search over indexed codebase files. Returns scored results with file paths and keywords.",
+            inputSchema: z.object({
+                query: z.string()
+                    .describe("Natural language search query"),
+                limit: z.number().int().min(1).max(100).default(5)
+                    .describe("Max results to return, 5 by default, 100 max"),
+            }),
+            annotations: {readOnlyHint: true},
+        }, async ({query, limit}) => {
+            try {
+                const format = FormatSearchResults();
+                const results = await searchContentIndex(query, limit);
+                const text = await format(query, results);
+                return {content: [{type: "text" as const, text}]};
+            } catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                log("xindex_search error:", msg);
+                return {content: [{type: "text" as const, text: msg}], isError: true};
+            }
+        });
+
+        // --- index ---
+
+        server.registerTool("xindex_index", {
+            title: "Index files or directories",
+            description: "Index files or directories for semantic search. " +
+                "Accepts file paths or directory paths. Directories are walked recursively, respecting .gitignore.",
+            inputSchema: z.object({
+                inputs: z.array(z.string()).min(1)
+                    .describe("File or directory paths to index"),
+            }),
+        }, async ({inputs}) => {
+            try {
+                await indexApp(inputs);
+                const stats = await getIndexStats();
+                return {content: [{
+                    type: "text" as const,
+                    text: `Indexed successfully. Total files: ${stats.indexedAmount}`,
+                }]};
+            } catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                log("xindex_index error:", msg);
+                return {content: [{type: "text" as const, text: msg}], isError: true};
+            }
+        });
+
+        // --- reset ---
+
+        server.registerTool("xindex_reset", {
+            title: "Reset index",
+            description: "Delete and recreate the search index. " +
+                "Always ask the user for explicit confirmation before running this tool.",
+            inputSchema: z.object({}),
+            annotations: {destructiveHint: true},
+        }, async () => {
+            try {
+                await resetIndex();
+                return {content: [{type: "text" as const, text: "Index reset successfully"}]};
+            } catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                log("xindex_reset error:", msg);
+                return {content: [{type: "text" as const, text: msg}], isError: true};
+            }
+        });
+
+        // --- start ---
+
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        log("xindex MCP server running on stdio");
+
+        if (watch) {
+            const startWatch = WatchFileEventsApp({...watch, log});
+            startWatch();
+        }
+    };
+}

package/apps/run.index.ts

@@ -0,0 +1,19 @@
+import {BuildComponents} from "../componets/buildComponents.js";
+import {BufferedLoggerToStdOut} from "../componets/logger.js";
+import {WalkFiles} from "../componets/walkFiles.js";
+import {IndexApp} from "./indexApp.js";
+import {AppId} from "../componets/appId.js";
+
+const appId = AppId();
+const cwd = process.cwd();
+const log = BufferedLoggerToStdOut();
+const {indexContent, removeContent, getIndexStats, config} = await BuildComponents({log});
+const walkFiles = WalkFiles({cwd, log, ignoreFiles: config.ignoreFiles});
+const indexApp = IndexApp({walkFiles, indexContent, removeContent, log});
+
+const inputs = process.argv.slice(2);
+if (!inputs.length) inputs.push(".");
+
+log(`[${appId}] started, indexing: ${inputs.join(", ")}`);
+await indexApp(inputs);
+log(`[${appId}] done:`, await getIndexStats());

package/apps/run.mcp.ts

@@ -0,0 +1,49 @@
+import {BuildComponents} from "../componets/buildComponents.js";
+import {HandleFileEvent} from "../componets/index/handleFileEvent.js";
+import {BufferedLoggerToStdErr} from "../componets/logger.js";
+import {WalkFiles} from "../componets/walkFiles.js";
+import {WatchFiles} from "../componets/watchFiles.js";
+import {WatcherLock} from "../componets/index/watcherLock.js";
+import {IndexApp} from "./indexApp.js";
+import {McpApp} from "./mcpApp.js";
+import {join} from "path";
+import {AppId} from "../componets/appId.js";
+
+const args = process.argv.slice(2);
+const watchDirArg = args.find(a => a.startsWith("--watch-dir="));
+const watchDisabled = args.includes("--watch-disabled");
+
+const cwd = process.cwd();
+const log = BufferedLoggerToStdErr();
+const {indexContent, removeContent, getIndexStats, searchContentIndex, resetIndex, config} = await BuildComponents({log});
+const walkFiles = WalkFiles({cwd, log, ignoreFiles: config.ignoreFiles});
+const indexApp = IndexApp({walkFiles, indexContent, removeContent, log});
+
+const appId = AppId();
+const watcherLock = WatcherLock({
+    lockPath: join(cwd, ".xindex", "lock.json"),
+    appId,
+    log,
+});
+
+const watch = watchDisabled ? undefined : {
+    watchFiles: WatchFiles({cwd, log, ignoreFiles: config.ignoreFiles}),
+    watchDir: watchDirArg ? watchDirArg.split("=")[1] : ".",
+    handleFileEvent: HandleFileEvent({indexContent, removeContent, log}),
+    watcherLock,
+};
+
+process.on("SIGINT", async () => {
+    log(`[${appId}] shutting down — stopping heartbeat...`);
+    watcherLock.stopHeartbeat();
+    log(`[${appId}] releasing lock...`);
+    await watcherLock.release();
+    log(`[${appId}] waiting 7s for another watcher to take over...`);
+    await new Promise(r => setTimeout(r, 7000));
+    log(`[${appId}] exiting`);
+    process.exit(0);
+});
+
+log(`[${appId}] started`);
+const mcpApp = McpApp({searchContentIndex, indexApp, getIndexStats, resetIndex, log, watch, config});
+await mcpApp();

package/apps/run.reset.ts

@@ -0,0 +1,10 @@
+import {BuildComponents} from "../componets/buildComponents.js";
+import {BufferedLoggerToStdOut} from "../componets/logger.js";
+import {AppId} from "../componets/appId.js";
+
+const appId = AppId();
+const log = BufferedLoggerToStdOut();
+const {resetIndex} = await BuildComponents({log});
+log(`[${appId}] resetting index...`);
+await resetIndex();
+log(`[${appId}] done`);