indexer-cli 0.12.14 → 0.12.16

package/README.md

@@ -7,7 +7,7 @@ right code.
 
 The main feature of `indexer-cli` is not just search on its own: it turns your repository into something coding agents
 can navigate efficiently. Running `idx init` installs a project-local discovery skill so Claude, OpenCode, and similar
-tools can pick the right indexed workflow instead of wasting tokens on blind `grep`, `find`, and repeated file reads.
+tools can pick the right indexed workflow instead of wasting tokens on blind `rg`/`grep`, `find`, and repeated file reads.
 
 Under the hood, `indexer-cli` indexes source code, generates vector embeddings through a local Ollama instance, and
 stores everything in a per-project `.indexer-cli/` directory. That gives both humans and agents fast natural-language
@@ -79,7 +79,7 @@ before they start burning tokens on broad filesystem scans.
 
 ## Why agents save tokens with this
 
-Without repo-local skills, agents often spend tokens on repetitive repository discovery: broad `grep`, repeated file
+Without repo-local skills, agents often spend tokens on repetitive repository discovery: broad `rg`/`grep`, repeated file
 reads, and trial-and-error navigation. With `indexer-cli`, agents can load one focused discovery skill and start from
 the right indexed path immediately.
 
@@ -107,7 +107,7 @@ idx architecture
 All discovery commands return human-readable text output, optimized for coding agents.
 
 This is especially useful in Claude and OpenCode setups, where project-local skills can guide the agent away from
-blind `grep`/`find` usage and toward indexed discovery, which usually means less wasted context and lower token usage
+blind `rg`/`grep`/`find` usage and toward indexed discovery, which usually means less wasted context and lower token usage
 during repo discovery.
 
 ## CLI Commands

package/dist/cli/commands/skills.js

@@ -1,14 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GENERATED_SKILL_DIRECTORIES = exports.DEPRECATED_SKILL_DIRECTORIES = exports.GENERATED_SKILLS = void 0;
-exports.GENERATED_SKILLS = [
-    {
-        name: "repo-discovery",
-        directory: "repo-discovery",
-        content: `---
+function buildRepoDiscoverySkillContent() {
+    return `---
 name: repo-discovery
-description: FIRST choice for repository discovery and code understanding. Use this to choose the cheapest indexed path for architecture, structure, behavior, symbol, AST, or dependency questions before broad file reads or grep.
-allowed-tools: Bash(idx architecture:*), Bash(idx structure:*), Bash(idx ast:*), Bash(idx search:*), Bash(idx explain:*), Bash(idx deps:*)
+description: FIRST choice for repository discovery and code understanding. Use this to choose the cheapest indexed path for architecture, structure, behavior, symbol, AST, or dependency questions before broad file reads or blind text search.
+allowed-tools: Bash(idx architecture:*), Bash(idx structure:*), Bash(idx ast:*), Bash(idx search:*), Bash(idx explain:*), Bash(idx deps:*), Bash(rg:*), Bash(grep:*)
 ---
 
 # Use repo-discovery as the indexed entry point
@@ -21,7 +18,7 @@ Pick the single cheapest command that answers the question, run it, and stop whe
 
 - \`idx architecture\` — repo shape, entry points, module boundaries, cycle causes, unresolved dependency classes
 - \`idx structure\` — file trees, exported symbols with line ranges, contents of a directory/module
-- \`idx ast <file>\` — compact syntax tree for one large file when symbol ranges are too coarse
+- \`idx ast <file>\` — compact syntax tree for one large file; use before repeated reads when ranges are coarse or JSX/parent structure matters
 - \`idx search\` — conceptual behavior questions like "how does X work?"; returns ranked file ranges plus \`why=\` reason codes
 - \`idx explain\` — a known symbol when you want indexed explanation
 - \`idx deps\` — imported-by/imports or impact for a known path/module
@@ -33,7 +30,7 @@ Pick the single cheapest command that answers the question, run it, and stop whe
 - Use \`--path-prefix\` whenever the subsystem is known, e.g. \`src/api/\`, \`src/auth/\`.
 - For \`idx structure\`, also narrow with \`--kind\` when possible.
 - If \`idx structure\` prints \`TRUNC\`/\`NEXT\`, run the \`NEXT\` command only when the hidden page is still relevant.
-- Use \`idx ast <file>\` only after you know the file is relevant and need a map of a large file before reading ranges.
+- Use \`idx ast <file>\` after you know a large file is relevant and need a map before reading ranges; if you are about to make a second overlapping \`Read\` on that file, run \`idx ast\` first.
 - If \`idx ast\` prints \`TRUNC\`/\`NEXT\`, run \`NEXT\` only when the hidden nodes are still relevant.
 - For \`idx deps\`, start with \`--depth 1\`; increase only if first-hop impact is insufficient.
 - For \`idx explain\`, prefer \`file::symbol\` when the name may be ambiguous.
@@ -43,17 +40,17 @@ Pick the single cheapest command that answers the question, run it, and stop whe
 - Do **not** run \`idx explain\` as a prelude to reading a file you already know you need.
 - Do **not** chain discovery steps mechanically (\`search → explain\`, \`explain → Read\`) when direct reading is cheaper.
 
-## Use idx vs grep/LSP
+## Use idx vs exact text search/LSP
 
 idx is **semantic** search: use it when you do **not** know the exact name and need to find code by meaning.
 
-Use \`grep\`/LSP when the target is already concrete:
-- exact identifier name → \`grep\`, \`lsp_symbols\`, or references/definition tools
+Use exact text search/LSP when the target is already concrete:
+- exact identifier name → \`rg\` (preferred), \`grep\`, \`lsp_symbols\`, or references/definition tools
 - exact small file path → \`Read\`
-- exact large file path + unknown internal layout → \`idx ast <file>\`, then read the smallest ranges
+- exact large file path + unknown internal layout or nested JSX → \`idx ast <file>\`, then read the smallest ranges
 - known file + known symbol → \`idx explain file::symbol\` or LSP if exact lookup is enough
 
-Rule of thumb: if you can write an exact search pattern, use \`grep\`/LSP. Use idx for exploration, not lookup.
+Rule of thumb: avoid broad blind \`rg\`/\`grep\`/\`find\` during discovery, but if you can write an exact search pattern, use \`rg\`/LSP. Use idx for exploration, not lookup.
 
 ## Query guidance
 
@@ -99,12 +96,12 @@ idx deps src/api/client.ts --show-edges
 idx search "MyType" --path-prefix src/models/
 
 # Better: exact lookup is cheaper
-grep "MyType" src/models/
+rg -n "MyType" src/models/
 \`\`\`
 
 ## Skip idx when
 
-- you already know the exact file to read
+- you already know the exact small file/range to read
 - you need an exact identifier lookup
 - you already know the file and want document-local symbols/usages
 - you are done discovering and are now editing or validating code
@@ -117,7 +114,13 @@ grep "MyType" src/models/
 - Search: \`idx search <query> [--max-files <n>] [--path-prefix <area>] [--chunk-types <types|api|impl|tests|imports>] [--mode hybrid|semantic|lexical|symbol] [--min-score <score>] [--include-content] [--include-imports] [--dedupe-file] [--dedupe-symbol] [--cluster] [--exclude-tests] [--include-tests]\`
 - Explain: \`idx explain <symbol|file::symbol> [--path-prefix <area>] [--include-fixtures] [--include-body] [--body-lines <n>] [--signature-only]\`
 - Deps: \`idx deps <path> [--direction callers|callees|both] [--depth <n>] [--show-edges] [--tests]\`
-`,
+`;
+}
+exports.GENERATED_SKILLS = [
+    {
+        name: "repo-discovery",
+        directory: "repo-discovery",
+        content: buildRepoDiscoverySkillContent(),
     },
 ];
 exports.DEPRECATED_SKILL_DIRECTORIES = [

package/dist/cli/commands/skills.js.map

@@ -1 +1 @@
-{"version":3,"file":"skills.js","sourceRoot":"","sources":["../../../src/cli/commands/skills.ts"],"names":[],"mappings":";;;AAMa,QAAA,gBAAgB,GAAqB;IACjD;QACC,IAAI,EAAE,gBAAgB;QACtB,SAAS,EAAE,gBAAgB;QAC3B,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgHV;KACC;CACD,CAAC;AAEW,QAAA,4BAA4B,GAAG;IAC3C,cAAc;IACd,iBAAiB;IACjB,gBAAgB;IAChB,mBAAmB;IACnB,gBAAgB;IAChB,kBAAkB;CAClB,CAAC;AAEW,QAAA,2BAA2B,GAAG,wBAAgB,CAAC,GAAG,CAC9D,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,CAC1B,CAAC"}
+{"version":3,"file":"skills.js","sourceRoot":"","sources":["../../../src/cli/commands/skills.ts"],"names":[],"mappings":";;;AAMA,SAAS,8BAA8B;IACtC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgHP,CAAC;AACF,CAAC;AAEY,QAAA,gBAAgB,GAAqB;IACjD;QACC,IAAI,EAAE,gBAAgB;QACtB,SAAS,EAAE,gBAAgB;QAC3B,OAAO,EAAE,8BAA8B,EAAE;KACzC;CACD,CAAC;AAEW,QAAA,4BAA4B,GAAG;IAC3C,cAAc;IACd,iBAAiB;IACjB,gBAAgB;IAChB,mBAAmB;IACnB,gBAAgB;IAChB,kBAAkB;CAClB,CAAC;AAEW,QAAA,2BAA2B,GAAG,wBAAgB,CAAC,GAAG,CAC9D,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,CAC1B,CAAC"}

package/dist/core/skills-version.d.ts

@@ -1 +1 @@
-export declare const SKILLS_VERSION = 3355244366;
+export declare const SKILLS_VERSION = 503726199;

package/dist/core/skills-version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SKILLS_VERSION = void 0;
-exports.SKILLS_VERSION = 3355244366;
+exports.SKILLS_VERSION = 503726199;
 //# sourceMappingURL=skills-version.js.map

package/dist/core/skills-version.js.map

@@ -1 +1 @@
-{"version":3,"file":"skills-version.js","sourceRoot":"","sources":["../../src/core/skills-version.ts"],"names":[],"mappings":";;;AAAa,QAAA,cAAc,GAAG,UAAU,CAAC"}
+{"version":3,"file":"skills-version.js","sourceRoot":"","sources":["../../src/core/skills-version.ts"],"names":[],"mappings":";;;AAAa,QAAA,cAAc,GAAG,SAAS,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "indexer-cli",
-	"version": "0.12.14",
+	"version": "0.12.16",
 	"description": "Lightweight CLI project indexer with semantic search via Ollama",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",