1bcoder 0.1.9__tar.gz → 0.1.11__tar.gz

{1bcoder-0.1.9 → 1bcoder-0.1.11/1bcoder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: 1bcoder
-Version: 0.1.9
+Version: 0.1.11
 Summary: AI coding assistant agent for 1B–7B local models (Ollama, LMStudio, llama.cpp). Terminal REPL with file editing, project map, agents, scripts, and parallel multi-model queries.
 Project-URL: Homepage, https://github.com/szholobetsky/1bcoder
 Project-URL: Repository, https://github.com/szholobetsky/1bcoder
@@ -13,6 +13,8 @@ Requires-Dist: tqdm>=4.64
 Requires-Dist: rich>=13.0
 Dynamic: license-file
 
+![1bcoder](images/1bcoder.png)
+
 # 1bcoder
 
 AI coding assistant for small local models (0.5B–4B) — runs via [Ollama](https://ollama.com), [LMStudio](https://lmstudio.ai), or any OpenAI-compatible backend.
@@ -59,7 +61,7 @@ Key design decisions:
 - **Short agent system prompts, at most 5 tools per agent, one function per agent** — `ask`, `edit`, `fill`, `scan`, `compact`. Not universal agents with bloated skill sets.
 - **Tolerant of long and malformed output** — post-processing is automatic; the programmer does not teach the model JSON syntax.
 - **`/parallel`** — send the same context to several models simultaneously and combine results; a 0.5b and a 1b model working together often outperform either alone; designed to coordinate small models running on multiple machines or phones.
-- **`/map`** — project structure index with structural diff; lets the model navigate a codebase without loading it into context.
+- **`/map`** — project structure index with structural diff and keyword grounding; lets the model navigate a codebase without loading it into context. Keyword extract supports three modes: exact, like (`%token%`), and fuzzy (subword); `-o` resolves each keyword to the files it appears in.
 - **`/ctx`** — surgical context management: savepoints, selective compaction, named context library, multi-turn rollback. Small models cannot afford wasted tokens.
 - **`/scan`** — reads any large file chunk by chunk and builds a themed summary without overflowing context.
 - **`/proc`** — parameterized command scripts for repeatable preparation workflows.
@@ -128,7 +130,7 @@ Tasks that require the model to decide *what to look at* — refactoring across
 - **Command autocorrection** — typos in command names, file paths, and keywords are detected and fixed automatically before execution, for both human input and agent actions
 - **`/tree [path]`** — display directory tree of the whole project or any subtree; ask to inject into context (or pass `ctx` to skip the prompt)
 - **`/find <pattern>`** — search filenames and file content with regex; supports `-f`/`-c`/`-i`/`--ext` flags; highlights matches, asks to inject results into context; sets `{{find_files}}` after every search; **`/find <terms> -r`** ranked BM25 mode returns top-10 files by relevance; hidden directories (`.git`, `.venv`, etc.) excluded automatically
-- AI proposes a **one-line fix** (`/fix`) or a **SEARCH/REPLACE patch** (`/patch`) — always shows a diff before applying
+- AI proposes a **one-line fix** (`/fix`), a **SEARCH/REPLACE patch** (`/patch`), or a **FIM-based fix** (`/fim`) — always shows a unified diff before applying
 - **Apply AI code blocks directly** with `/edit <file> code` (new/full file) or `/patch <file> code` (SEARCH/REPLACE from reply, no line numbers needed) — preferred for agent mode
 - **`<think>` tag support** — reasoning blocks shown in terminal by default; `/think hide` suppresses terminal display; `/think include` keeps reasoning in context for chained turns
 - Run shell commands and inject their output with `/run`
@@ -453,10 +455,12 @@ Then configure `/translate` to use it:
 | Command | Description |
 |---|---|
 | `/fix <file> [start-end] [hint]` | AI proposes one-line fix, shows diff, asks to apply |
+| `/fim <file> <line or start-end> [-w N] [hint]` | FIM-based fix — model rewrites the marked section, shows unified diff |
 | `/patch <file> [start-end] [hint]` | AI proposes SEARCH/REPLACE block, shows unified diff |
 | `/patch <file> code` | Apply SEARCH/REPLACE block from last AI reply (no new LLM call) |
 
-`/fix` is designed for 1B models — output is strictly constrained to `LINE N: content`.
+`/fix` asks the model to output `LINE N: content` — simple but small models often lose indentation.
+`/fim` (Fill-In-the-Middle) marks the target line(s) with `<<<...>>>` inside the full file, asks the model to return the corrected file, then diffs the result — no output format to learn, grammar constraints come from the surrounding code. Use `-w N` to limit context to N lines around the target when the file is larger than the context window.
 `/patch` works better with larger models (7B+) and can replace multiple consecutive lines.
 `/patch <file> code` is the preferred agent mode edit — the agent writes the SEARCH/REPLACE block in its reply, then calls `/patch <file> code` to apply it without needing line numbers.
 
@@ -465,6 +469,9 @@ When `/patch` fails to find the SEARCH text it shows a diagnostic diff — the S
 ```
 /fix main.py
 /fix main.py 2-2 wrong operator
+/fim main.py 3 replace != with ==
+/fim main.py 3-5 fix the logic
+/fim huge_file.py 14567 -w 20 fix indentation
 /patch main.py 10-40 fix the loop logic
 /patch main.py code
 ```
@@ -538,8 +545,8 @@ The map command scans your project with language-agnostic regex, extracts defini
 /map trace <start> <end> [-y]                  — shortest dependency path between two points
 /map idiff [path] [depth]                      — re-index then show diff vs previous snapshot
 /map diff                                      — show diff without re-indexing (safe to repeat)
-/map keyword index                             — build keyword vocabulary from map.txt
-/map keyword extract <text> [-f] [-a] [-n] [-c] — extract real identifiers from keyword.txt matching text/file
+/map keyword index                                  — build keyword vocabulary from map.txt
+/map keyword extract <text> [-f] [-l] [-a] [-s] [-n] [-c] [-o] — extract real identifiers from keyword.txt matching text/file
 ```
 
 **Partial / incremental indexing** — for large codebases where a full re-scan is slow:
@@ -583,6 +590,33 @@ This lets you re-index a changed module in seconds instead of hours.
 /map find models -d 2                    — filenames + defines/vars only
 ```
 
+**`/map keyword`** — two-step identifier grounding:
+
+```
+/map keyword index                   — scan map.txt → .1bcoder/keyword.txt (word, count, line refs)
+/map keyword extract "fix rule search" -l -o   — find identifiers, show which files they're in
+```
+
+Extract flags:
+
+| Flag | Mode | Effect |
+|---|---|---|
+| *(none)* | exact | query word must exactly match a keyword |
+| `-f` | fuzzy | splits camelCase/snake_case into subwords; matches if all query subwords (≥5 chars) appear in the identifier |
+| `-l` | like | substring match: any keyword containing the token (`%token%`) |
+| `-n` | — | show frequency count: `RuleIndex(25)` |
+| `-s` | — | sort by frequency descending |
+| `-a` | — | sort alphabetically |
+| `-c` | — | comma-separated output (default: one per line) |
+| `-o` | — | show origin files: `parameter_rule -> lib/cop/rule.rb, config/default.yml` |
+
+```
+/map keyword extract "add validation rule" -l -o
+# parameter_rule -> lib/rubocop/cop/style/rule.rb, config/default.yml
+# cop_rule       -> lib/rubocop/cop/base.rb
+# load_rules     -> lib/rubocop/config_loader.rb
+```
+
 **`/map trace`** — three modes:
 
 **1. Backwards BFS** (who depends on this?):
@@ -1712,7 +1746,7 @@ On Windows: hold `Shift` and drag with the left mouse button to select and copy
 ## Tips for 1B models
 
 - **Start small.** Use `/read file.py 10-25` instead of loading the whole file. Short context = better focus.
-- **Use `/fix` not `/patch`.** The `LINE N: content` format is much more reliable at 1B scale than free-form generation.
+- **Try `/fim` for tricky fixes.** FIM-based editing activates the model's grammar knowledge through surrounding code context — more reliable than `/fix` for indentation and multi-line logic. Use `-w 20` for large files.
 - **Build a map first.** Run `/map index .` at the start of a session, then use `/map find` to load only the relevant parts into context.
 - **Use scripts.** Scripts make multi-step work reproducible — the model only needs to handle one step at a time.
 - **Capture workflows.** After solving a task manually, run `/script create ctx` to save the exact steps as a reusable script.
@@ -1769,6 +1803,26 @@ For human input, the corrected command is shown with `[fix?]` and you are asked
 
 ---
 
+## Part of the SIMARGL toolkit
+
+1bcoder is one of four tools that together form an **intellectual development support system**:
+
+| Tool | Role |
+|---|---|
+| **[simargl](https://github.com/szholobetsky/simargl)** | Task-to-code retrieval — given a task description, finds which files and modules are likely affected, using semantic similarity over git history |
+| **[svitovyd](https://github.com/szholobetsky/svitovyd)** | Project map — scans any codebase and produces a structural map of definitions and cross-file dependencies; exposes it as an MCP server |
+| **[1bcoder](https://github.com/szholobetsky/1bcoder)** | AI coding assistant for small local models — surgical context management, agents, parallel inference, proc scripts |
+| **[yasna](https://github.com/szholobetsky/yasna)** | Session memory — indexes conversations from all AI agents so you can find what was discussed, when, and where |
+
+- **simargl** answers: *what code is related to this task?*
+- **svitovyd** answers: *how is the code structured and what depends on what?*
+- **1bcoder** answers: *how do I work with local models efficiently?*
+- **yasna** answers: *where did I already discuss this?*
+
+Together they cover the full development loop: understand the codebase, find relevant history, work with AI locally, remember what was decided.
+
+---
+
 **(c) 2026 Stanislav Zholobetskyi**
 Institute for Information Recording, National Academy of Sciences of Ukraine, Kyiv
 *PhD research: «Intelligent Technology for Software Development and Maintenance Support»*