xindex 1.0.2 → 1.0.4

package/features/removeContent.ts

@@ -1,9 +1,9 @@
 import {IndexCommandType, IIndexApi} from "../componets/index/indexApi.js";
 
-export type IRemoveContent = (id: string) => Promise<void>;
+export type IRemoveContent = (ids: string[]) => Promise<void>;
 
 export function RemoveContent({indexApi}: {indexApi: IIndexApi}): IRemoveContent {
-    return async function removeContent(id) {
-        await indexApi({type: IndexCommandType.delete, id});
+    return async function removeContent(ids) {
+        await indexApi({type: IndexCommandType.delete, ids});
     }
 }

package/features/searchIndex.ts

@@ -2,26 +2,37 @@ import {LocalIndex} from "vectra";
 import {IEmbed} from "../componets/llm/embed.js";
 import {IExtractKeywords} from "../componets/keywords/extractKeywords.js";
 import {ICleanUpKeywords} from "../componets/keywords/cleanUpKeywords.js";
+import {ILocateInFile} from "../componets/locate/locateInFile.js";
 
-export type IIndexRecord = { score: number; id: string; keywords: string };
+export type IIndexRecord = {
+    score: number;
+    id: string;
+    keywords?: string;
+    startPos?: number;
+    endPos?: number;
+    snippet?: string;
+    startLine?: number;
+    endLine?: number;
+};
 
 export type ISearchIndex = (query: string, limit: number) => Promise<IIndexRecord[]>;
 
-export function SearchIndex({extractKeywords, cleanUpKeywords, embed, index, scoreThreshold = 0.05}: {
+export function SearchIndex({extractKeywords, cleanUpKeywords, embed, index, locateInFile, scoreThreshold = 0.05}: {
     extractKeywords: IExtractKeywords,
     cleanUpKeywords: ICleanUpKeywords,
     embed: IEmbed,
     index: LocalIndex,
-    scoreThreshold?: number
+    locateInFile: ILocateInFile,
+    scoreThreshold: number
 }): ISearchIndex {
     return async function searchContentIndex(query, limit) {
         const keywords = cleanUpKeywords(extractKeywords(query));
         const searchText = keywords.length > 0 ? keywords.join(", ") : query;
         const vector = await embed(searchText);
 
-        const results = await index.queryItems(vector, searchText, limit);
+        const results = await index.queryItems(vector, searchText, limit * 2);
 
-        return results
+        const candidates = results
             .filter(r => r.score >= scoreThreshold)
             .sort((a, b) => b.score - a.score)
             .map(r => ({
@@ -29,5 +40,11 @@ export function SearchIndex({extractKeywords, cleanUpKeywords, embed, index, sco
                 id: r.item.id,
                 keywords: typeof r.item.metadata?.keywords === "string" ? r.item.metadata.keywords : "",
             }));
+
+        if (!locateInFile || candidates.length === 0) {
+            return candidates;
+        }
+
+        return locateInFile(query, vector, candidates, limit);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xindex",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Local semantic code search — index codebase, search by meaning or keywords",
   "type": "module",
   "main": "xindex.ts",
@@ -16,9 +16,19 @@
     "search": "tsx apps/run.search.ts",
     "reset": "tsx apps/run.reset.ts",
     "mcp": "tsx apps/run.mcp.ts",
-    "watch": "tsx apps/run.watch.ts"
+    "watch": "tsx apps/run.watch.ts",
+    "test.compilation": "npx -y tsc --ignoreConfig --noEmit --target ES2022 --module ESNext --moduleResolution bundler --esModuleInterop --skipLibCheck --strict false $(git ls-files '*.ts')"
   },
   "private": false,
+  "keywords": [
+    "semantic-search",
+    "code-search",
+    "mcp",
+    "claude-code",
+    "embeddings",
+    "local-first",
+    "developer-tools"
+  ],
   "dependencies": {
     "@huggingface/transformers": "^4.0.1",
     "@modelcontextprotocol/sdk": "^1.29.0",
@@ -28,5 +38,8 @@
     "tsx": "^4.21.0",
     "vectra": "^0.14.0",
     "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.3"
   }
 }

package/packages/streamx/src/batchTimed.ts

@@ -1,7 +1,7 @@
 import { StreamXMapper } from './index';
 import { IRead, read } from './reader';
 import { IWriter, Writer } from './writer';
-import { syncTick } from '@handy/fun/tick';
+import { syncTick } from '../../fun/src/tick';
 import { clearTimeout } from 'timers';
 
 type Milliseconds = number;

package/packages/streamx/src/buffer.ts

@@ -1,7 +1,7 @@
 import { StreamX, StreamXMapper } from './index';
 import { IRead, read } from './reader';
 import { IWriter, Writer } from './writer';
-import { syncTick } from '@handy/fun/tick';
+import { syncTick } from '../../fun/src/tick';
 
 export function buffer<Input>(size: number): StreamXMapper<Input, Input> {
   let outputBuffer: IWriter<Input>;

package/packages/streamx/src/defer.ts

@@ -0,0 +1,55 @@
+export type IDefer<ResultType = void> = {
+  promise: Promise<ResultType>;
+  resolved: boolean;
+  rejected: boolean;
+  pending: boolean;
+  resolve(value: ResultType | PromiseLike<ResultType>): void;
+  reject(reason?: unknown): void;
+};
+
+export function Defer<ResultType = void>(): IDefer<ResultType> {
+  const deferred = {
+    rejected: false,
+    resolved: false,
+    pending: true,
+  } as IDefer<ResultType>;
+
+  deferred.promise = new Promise<ResultType>((resolve, reject) => {
+    deferred.resolve = (data: any) => {
+      if (deferred.resolved || deferred.rejected) {
+        return;
+      }
+
+      deferred.pending = false;
+      deferred.resolved = true;
+      resolve(data);
+    };
+
+    deferred.reject = (error: any) => {
+      if (deferred.resolved || deferred.rejected) {
+        return;
+      }
+
+      deferred.pending = false;
+      deferred.rejected = true;
+      reject(error);
+    };
+  });
+
+  return deferred;
+}
+
+export type IDataDefer<DataType = any, ResultType = void> = IDefer<ResultType> & {
+  data: DataType;
+};
+
+export function DeferData<DataType = void, ResultType = void>(
+  data: DataType
+): IDataDefer<DataType, ResultType> {
+  const deferred = Defer<ResultType>();
+
+  return {
+    ...deferred,
+    data,
+  };
+}

package/packages/streamx/src/interval.ts

@@ -1,4 +1,4 @@
-import { Defer } from '@handy/fun/defer';
+import { Defer } from '../../fun/src/defer';
 import { reader } from './reader';
 import { StreamX } from './index';
 

package/packages/streamx/src/merge.ts

@@ -1,7 +1,7 @@
 import { StreamX } from './index';
 import { IRead, read } from './reader';
 import { IWriter, Writer } from './writer';
-import { syncTick } from '@handy/fun/tick';
+import { syncTick } from '../../fun/src/tick';
 
 export function merge<T1, T2, T3, T4>(
   stream1: StreamX<T1>,

package/packages/streamx/src/nodeWritable.ts

@@ -1,6 +1,6 @@
 import { StreamX, StreamXMapper } from './index';
 import { Writable } from 'stream';
-import { Defer } from '@handy/fun/defer';
+import { Defer } from '../../fun/src/defer';
 
 export function nodeWritable<Type>(
   writable: Writable,

package/packages/streamx/src/scale.ts

@@ -1,8 +1,8 @@
 import { Promised, StreamXMapper } from './index';
 import { IRead, read } from './reader';
 import { IWriter, Writer } from './writer';
-import { Concurrency, IPublishToConcurrency } from '@handy/fun/concurrency';
-import { syncTick } from '@handy/fun/tick';
+import { Concurrency, IPublishToConcurrency } from '../../fun/src/concurrency';
+import { syncTick } from '../../fun/src/tick';
 
 export function scale<Input, Output>(
   max: number,

package/packages/streamx/src/writer.ts

@@ -1,4 +1,4 @@
-import { Defer, IDefer } from '@handy/fun/defer';
+import { Defer, IDefer } from './defer';
 import { of, StreamX } from './index';
 import { reader } from './reader';
 import { flat } from './flat';

package/.claude/settings.local.json

@@ -1,73 +0,0 @@
-{
-  "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

@@ -1,8 +0,0 @@
----
-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

@@ -1,38 +0,0 @@
-## 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

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

package/media/MEDIUM.md

@@ -1,139 +0,0 @@
-# xindex — local semantic code search, with an MCP server built in
-
-> Index your repo, search by meaning, no cloud. Works with Claude Code out of the box.
-
----
-
-## The problem
-
-You land in a 50,000-line codebase someone else wrote. You need "the part that handles auth retries."
-
-```
-grep -r "retry" .
-```
-
-200 matches. Most unrelated. You try `auth`. 400 matches.
-
-You know what you want. You just can't spell it in one string.
-
-## Why I built this
-
-I wanted grep's ergonomics with a real search engine's semantics — but running entirely on my laptop. Cloud code search solves the meaning problem, but I'm not uploading half-finished private repos to anyone's servers. IDE search works inside files you've already found. Neither answers *"where in this entire repo is X done?"* without the round-trip to the cloud.
-
-So I built a small tool that indexes a repo once and lets me ask it questions. Then the MCP ecosystem happened, and the same index became the single most useful thing I could hand to Claude Code.
-
-## What xindex is
-
-A small CLI that indexes your codebase and lets you search it by natural-language meaning. It also runs as an MCP server, so Claude Code (or any MCP client) can call it directly.
-
-- **Local** — nothing leaves your machine
-- **Semantic** — natural-language queries, not substring matches
-- **MCP built in** — four lines of JSON to wire into Claude Code
-- **Watch mode** — keeps the index fresh as you edit
-- **Gitignore-aware** — plus your own rules
-
-What it's *not*: not a grep replacement (exact strings — grep wins), not code intelligence (no symbols/refs — your IDE wins). It's a focused semantic index. Nothing more.
-
-## 30 seconds, end to end
-
-```bash
-npm i -g xindex
-
-cd my-project
-xindex-index .
-xindex-search "rate limiter logic"
-```
-
-First run downloads a ~23MB embedding model (one time). Then you get ranked file paths back — enough to jump straight to the right place.
-
-## The part I'm actually excited about
-
-Semantic search is one of the highest-leverage tools you can give an AI assistant in an unfamiliar repo.
-
-Drop this into `.mcp.json`:
-
-```json
-{
-  "mcpServers": {
-    "xindex": {
-      "command": "xindex-mcp",
-      "args": []
-    }
-  }
-}
-```
-
-Open the project in Claude Code. Ask about your codebase. Watch Claude call `xindex_search` and come back with real file references instead of invented ones.
-
-The hallucinations drop. The round-trips drop. That alone was worth shipping.
-
-## What I'm not pretending
-
-v1 of a tool I built for myself:
-
-- First run needs network (model download)
-- One repo at a time; no cross-repo search
-- No AST awareness — works on keywords, not structure
-- Quality depends on descriptive names — `x1`, `foo`, `tmp` won't index well
-
-If it breaks on your repo, that's the feedback I want most.
-
-## Try it
-
-```bash
-npm i -g xindex
-```
-
-- **npm**: [npmjs.com/package/xindex](https://www.npmjs.com/package/xindex)
-
-What I'd love to hear: does the quality hold up on your repo? What does it fumble? What would make it genuinely useful day-to-day?
-
-DM me directly:
-
-- **X / Twitter**: [@slavahatnuke](https://x.com/slavahatnuke)
-- **LinkedIn**: [slava-xatnuk](https://www.linkedin.com/in/slava-xatnuk/)
-
----
-
-<!-- APPENDIX — not part of the post, for screenshots only -->
-
-## Screenshot queries (for the post)
-
-### Terminal demo (`xindex-search` output)
-
-Good candidates — run inside the xindex repo itself to get clean, relatable results:
-
-1. `xindex-search "where is the MCP server registered"`
-2. `xindex-search "file watcher debounce"`
-3. `xindex-search "how keywords are extracted"`
-4. `xindex-search "gitignore handling"`
-5. `xindex-search "how is the vector index stored"`
-
-Pick the one with the cleanest output. #1 tends to match well because "MCP" is distinctive.
-
-### Claude Code + xindex (mid-post screenshot)
-
-Open Claude Code in a project with xindex wired into `.mcp.json`. Ask it something where you can visibly see it invoke `xindex_search`:
-
-1. *"Where does xindex handle the file watcher lock?"*
-2. *"Show me how the MCP server wires up its tools."*
-3. *"How does indexing decide what to skip?"*
-
-The win is the screenshot showing the tool call panel — Claude asking `xindex_search` and getting real paths back. That's the image that sells MCP integration.
-
-## Cover image — Gemini prompt
-
-Pick one direction:
-
-All options: **light background, airy, meaningful, minimal.**
-
-**Option A — constellation of meaning:**
-> A minimalist editorial illustration on a soft off-white background. A small cluster of delicate paper-thin file cards floats in the center, connected by fine pastel threads that converge toward one highlighted card in gentle focus. Hints of pale blue, soft coral, and warm sand. Lots of negative space. No text. Flat 2D style with subtle grain. 16:9.
-
-**Option B — finding the thread:**
-> A light, airy illustration on a pale cream background. A single thin glowing line weaves through a loose scatter of abstract document shapes and lands on one, softly illuminating it. Muted pastels: sky blue, soft peach, mint. Calm, almost meditative. Generous negative space. No text. Minimal editorial style. 16:9.
-
-**Option C — lens on meaning:**
-> A clean, bright illustration on white. A simple line-drawn magnifying glass hovers over a gently organized pattern of small abstract symbols; the symbols inside the lens rearrange into a neat constellation while those outside stay scattered. Warm pastel accents — peach, sage, sky. Thin lines, soft shadows, plenty of whitespace. No text. 16:9.
-
-My pick: **B** — "finding the thread" maps directly to what xindex does (one connection through the noise), reads well at thumbnail size, and stays quiet enough not to fight the headline.

package/media/SOCIAL.md

@@ -1,102 +0,0 @@
-# xindex — social posts & announcements
-
-Links:
-- **npm**: https://www.npmjs.com/package/xindex
-- **Medium**: https://medium.com/@slavahatnuke/xindex-local-semantic-code-search-with-an-mcp-server-built-in-4a74c24d62b7
-- **Launch tweet (pinned)**: https://x.com/slavahatnuke/status/2045214244367470721
-
----
-
-## LinkedIn — announcement (main version)
-
-> Just shipped **xindex** — a small tool I built to solve a problem I kept hitting: finding "the part that handles X" in unfamiliar codebases.
->
-> grep matches text. xindex matches meaning. Fully local — your code never leaves your machine.
->
-> It also runs as an MCP server, which means Claude Code (and any MCP-compatible assistant) can search your repo directly. The hallucinations drop. The round-trips drop. That's the part I'm most excited about.
->
-> `npm i -g xindex`
->
-> I wrote up the why, the how, and honest limitations here:
-> 👉 https://medium.com/@slavahatnuke/xindex-local-semantic-code-search-with-an-mcp-server-built-in-4a74c24d62b7
->
-> Would love feedback from anyone using Claude Code day-to-day — especially what breaks on your repo.
->
-> #DeveloperTools #MCP #ClaudeCode #AI #OpenSource
-
----
-
-## LinkedIn — shorter variant (2–3 lines)
-
-> Shipped **xindex** — local semantic code search for your codebase, with an MCP server built in so Claude Code can use it directly.
->
-> `npm i -g xindex` · write-up 👉 https://medium.com/@slavahatnuke/xindex-local-semantic-code-search-with-an-mcp-server-built-in-4a74c24d62b7
->
-> Feedback welcome 🙏
->
-> #DeveloperTools #MCP #ClaudeCode
-
----
-
-## LinkedIn — longer narrative variant
-
-> A few weeks ago I got tired of grepping through a codebase I didn't write, trying to find "the part that handles auth retries." `grep retry` gave me 200 matches. `grep auth` gave me 400. I knew what I wanted — I just couldn't spell it in one string.
->
-> So I built **xindex**.
->
-> It's a small tool that indexes a codebase and lets you search it by natural-language meaning. Fully local — nothing leaves your machine. And because it runs as an MCP server, Claude Code (or any MCP-compatible assistant) can call it directly to find relevant files without inventing paths.
->
-> The assistant-integration part is what I'm most excited about. Semantic search is one of the highest-leverage tools you can hand to an AI working in an unfamiliar repo.
->
-> `npm i -g xindex`
->
-> Full write-up — why I built it, how it works, honest limitations:
-> 👉 https://medium.com/@slavahatnuke/xindex-local-semantic-code-search-with-an-mcp-server-built-in-4a74c24d62b7
->
-> If you use Claude Code day-to-day, I'd love to hear what breaks on your repo.
->
-> #DeveloperTools #MCP #ClaudeCode #AI #OpenSource
-
----
-
-## X / Twitter — reply to pinned tweet
-
-Reply thread under the pinned launch tweet to extend its reach:
-
-> Wrote up the full story on Medium — why I built it, how it works, and what it won't do.
->
-> https://medium.com/@slavahatnuke/xindex-local-semantic-code-search-with-an-mcp-server-built-in-4a74c24d62b7
-
----
-
-## X / Twitter — quote-tweet (24–48h after launch)
-
-Quote your own pinned tweet to revive it:
-
-> A few days in — some early feedback coming in. If you missed it, here's the write-up:
->
-> https://medium.com/@slavahatnuke/xindex-local-semantic-code-search-with-an-mcp-server-built-in-4a74c24d62b7
-
----
-
-## Publishing checklist
-
-- [ ] Pin launch tweet on X
-- [ ] Reply to pinned tweet with Medium link
-- [ ] Post LinkedIn announcement (main version)
-- [ ] Pin LinkedIn post to profile
-- [ ] Drop Medium link in any relevant Slack / Discord communities you're in
-- [ ] Submit Medium post to a publication (Better Programming / Level Up Coding / ILLUMINATION) if you're a contributor
-- [ ] 48h later: quote-tweet own pinned tweet for a second wave
-
----
-
-## Ongoing content ideas (post-launch)
-
-For later, when you have something to say:
-
-1. **Demo GIF** — record `xindex-index` + `xindex-search` on a real repo; post as standalone tweet
-2. **"grep vs xindex" side-by-side** — the punchier tweet variant you considered, once you have usage to back it up
-3. **Claude Code screencast** — record Claude invoking `xindex_search` and answering a real question; post on X + LinkedIn
-4. **Lessons / numbers** — after a week: "xindex hit N installs, here's what I learned"
-5. **Feature posts** — as you add capabilities, short posts on each

package/rnd/hf.ts

@@ -1,14 +0,0 @@
-import { pipeline } from "@huggingface/transformers";
-
-const generator = await pipeline(
-  "text-generation",
-  "HuggingFaceTB/SmolLM2-135M-Instruct"
-);
-
-const messages = [
-  { role: "system", content: "You are a helpful assistant." },
-  { role: "user", content: "Who is Microsoft?" },
-];
-
-const output = await generator(messages, { max_new_tokens: 64 });
-console.log(output[0].generated_text.at(-1).content);

package/rnd/keywords-compromise.ts

@@ -1,18 +0,0 @@
-import nlp from "compromise";
-import { readFile } from "fs/promises";
-
-const filePath = process.argv[2];
-if (!filePath) {
-  console.error("Usage: npx tsx keywords-compromise.ts <file>");
-  process.exit(1);
-}
-
-const text = await readFile(filePath, "utf8");
-const doc = nlp(text);
-
-console.log(`Keywords from: ${filePath}\n`);
-console.log("Topics:", doc.topics().out("array"));
-console.log("\nNouns:", doc.nouns().out("array"));
-console.log("\nVerbs:", doc.verbs().out("array"));
-console.log("\nPeople:", doc.people().out("array"));
-console.log("\nOrganizations:", doc.organizations().out("array"));