1bcoder 0.1.7__tar.gz → 0.1.8__tar.gz

{1bcoder-0.1.7 → 1bcoder-0.1.8}/1bcoder.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: 1bcoder
-Version: 0.1.7
+Version: 0.1.8
 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
@@ -371,10 +371,7 @@ Config is saved globally to `~/.1bcoder/translate.json` and applied automaticall
 | `/translate on` | Enable translation (uses saved language and mode) |
 | `/translate off` | Disable translation |
 | `/translate status` | Show lang, mode, lm_host, lm_model, enabled |
-| `/translate lang <code>` | Change language |
-| `/translate mode online\|mini\|offline\|lm [profile <name>]` | Switch mode; `profile` loads host+model from profiles.txt |
-| `/translate last` | Retranslate last reply |
-| `/translate last mode offline lang de` | Retranslate with overrides (mode / lang) |
+| `/translate last [mode:<m>] [lang:<code>]` | Retranslate last reply with optional overrides |
 
 Common language codes: `uk` Ukrainian, `de` German, `fr` French, `pl` Polish, `es` Spanish, `zh` Chinese. Full list: `/doc translate`
 
@@ -412,7 +409,7 @@ lmtrans: 192.168.0.5:11434|translategemma:4b|ctx
 Then configure `/translate` to use it:
 
 ```
-/translate setup uk lm host 192.168.0.5:11434 model translategemma:4b
+/translate setup lang:uk mode:lm host:192.168.0.5:11434 model:translategemma:4b
 ```
 
 ---
@@ -1551,6 +1548,25 @@ Built-in team scripts in `~/.1bcoder/scripts/`:
 
 ---
 
+### Flows (`/flow`)
+
+Flows are deterministic Python pipelines — they run commands, loop over lists, and pass everything to the LLM in a **temporary context**. Only the final summary lands in your main conversation. Works reliably even with 1B models because the LLM only needs to read, not make tool decisions.
+
+```
+/flow list                          # list all available flows
+/flow webask what is asyncio -d 5   # web search → fetch top 5 pages → summarize
+/flow grounding fix MultilineTernary # extract codebase keywords → locate files → summarize
+/flow simargl_files add user auth   # simargl retrieval → read matched files → explain
+/flow py_error_trace -f error.txt   # parse traceback → read code at each location → explain
+/flow commit_message                # git diff → generate commit message
+```
+
+Custom flows go in `~/.1bcoder/flows/<name>.py` (global) or `.1bcoder/flows/<name>.py` (project-local).
+Each flow is a Python file with a single `run(chat, args)` function.
+Full guide: `/doc flows`
+
+---
+
 ### Session controls
 
 | Command | Description |

{1bcoder-0.1.7 → 1bcoder-0.1.8}/1bcoder.egg-info/SOURCES.txt

@@ -23,11 +23,19 @@ _bcoder_data/agents/fill.txt
 _bcoder_data/agents/planning.txt
 _bcoder_data/agents/scan.txt
 _bcoder_data/agents/sqlite.txt
+_bcoder_data/agents/websearch.txt
+_bcoder_data/doc/FLOWS.md
 _bcoder_data/doc/MCP.md
 _bcoder_data/doc/OLLAMA_SERVER_PARAM.md
 _bcoder_data/doc/PARAM.md
 _bcoder_data/doc/PROC.md
 _bcoder_data/doc/TRANSLATE.md
+_bcoder_data/flows/commit_message.py
+_bcoder_data/flows/grounding.py
+_bcoder_data/flows/py_error_trace.py
+_bcoder_data/flows/simargl_files.py
+_bcoder_data/flows/webask.py
+_bcoder_data/flows/__pycache__/commit_message.cpython-311.pyc
 _bcoder_data/proc/action-required.py
 _bcoder_data/proc/add-save.py
 _bcoder_data/proc/assist.py

{1bcoder-0.1.7 → 1bcoder-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: 1bcoder
-Version: 0.1.7
+Version: 0.1.8
 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
@@ -371,10 +371,7 @@ Config is saved globally to `~/.1bcoder/translate.json` and applied automaticall
 | `/translate on` | Enable translation (uses saved language and mode) |
 | `/translate off` | Disable translation |
 | `/translate status` | Show lang, mode, lm_host, lm_model, enabled |
-| `/translate lang <code>` | Change language |
-| `/translate mode online\|mini\|offline\|lm [profile <name>]` | Switch mode; `profile` loads host+model from profiles.txt |
-| `/translate last` | Retranslate last reply |
-| `/translate last mode offline lang de` | Retranslate with overrides (mode / lang) |
+| `/translate last [mode:<m>] [lang:<code>]` | Retranslate last reply with optional overrides |
 
 Common language codes: `uk` Ukrainian, `de` German, `fr` French, `pl` Polish, `es` Spanish, `zh` Chinese. Full list: `/doc translate`
 
@@ -412,7 +409,7 @@ lmtrans: 192.168.0.5:11434|translategemma:4b|ctx
 Then configure `/translate` to use it:
 
 ```
-/translate setup uk lm host 192.168.0.5:11434 model translategemma:4b
+/translate setup lang:uk mode:lm host:192.168.0.5:11434 model:translategemma:4b
 ```
 
 ---
@@ -1551,6 +1548,25 @@ Built-in team scripts in `~/.1bcoder/scripts/`:
 
 ---
 
+### Flows (`/flow`)
+
+Flows are deterministic Python pipelines — they run commands, loop over lists, and pass everything to the LLM in a **temporary context**. Only the final summary lands in your main conversation. Works reliably even with 1B models because the LLM only needs to read, not make tool decisions.
+
+```
+/flow list                          # list all available flows
+/flow webask what is asyncio -d 5   # web search → fetch top 5 pages → summarize
+/flow grounding fix MultilineTernary # extract codebase keywords → locate files → summarize
+/flow simargl_files add user auth   # simargl retrieval → read matched files → explain
+/flow py_error_trace -f error.txt   # parse traceback → read code at each location → explain
+/flow commit_message                # git diff → generate commit message
+```
+
+Custom flows go in `~/.1bcoder/flows/<name>.py` (global) or `.1bcoder/flows/<name>.py` (project-local).
+Each flow is a Python file with a single `run(chat, args)` function.
+Full guide: `/doc flows`
+
+---
+
 ### Session controls
 
 | Command | Description |

{1bcoder-0.1.7 → 1bcoder-0.1.8}/README.md

@@ -356,10 +356,7 @@ Config is saved globally to `~/.1bcoder/translate.json` and applied automaticall
 | `/translate on` | Enable translation (uses saved language and mode) |
 | `/translate off` | Disable translation |
 | `/translate status` | Show lang, mode, lm_host, lm_model, enabled |
-| `/translate lang <code>` | Change language |
-| `/translate mode online\|mini\|offline\|lm [profile <name>]` | Switch mode; `profile` loads host+model from profiles.txt |
-| `/translate last` | Retranslate last reply |
-| `/translate last mode offline lang de` | Retranslate with overrides (mode / lang) |
+| `/translate last [mode:<m>] [lang:<code>]` | Retranslate last reply with optional overrides |
 
 Common language codes: `uk` Ukrainian, `de` German, `fr` French, `pl` Polish, `es` Spanish, `zh` Chinese. Full list: `/doc translate`
 
@@ -397,7 +394,7 @@ lmtrans: 192.168.0.5:11434|translategemma:4b|ctx
 Then configure `/translate` to use it:
 
 ```
-/translate setup uk lm host 192.168.0.5:11434 model translategemma:4b
+/translate setup lang:uk mode:lm host:192.168.0.5:11434 model:translategemma:4b
 ```
 
 ---
@@ -1536,6 +1533,25 @@ Built-in team scripts in `~/.1bcoder/scripts/`:
 
 ---
 
+### Flows (`/flow`)
+
+Flows are deterministic Python pipelines — they run commands, loop over lists, and pass everything to the LLM in a **temporary context**. Only the final summary lands in your main conversation. Works reliably even with 1B models because the LLM only needs to read, not make tool decisions.
+
+```
+/flow list                          # list all available flows
+/flow webask what is asyncio -d 5   # web search → fetch top 5 pages → summarize
+/flow grounding fix MultilineTernary # extract codebase keywords → locate files → summarize
+/flow simargl_files add user auth   # simargl retrieval → read matched files → explain
+/flow py_error_trace -f error.txt   # parse traceback → read code at each location → explain
+/flow commit_message                # git diff → generate commit message
+```
+
+Custom flows go in `~/.1bcoder/flows/<name>.py` (global) or `.1bcoder/flows/<name>.py` (project-local).
+Each flow is a Python file with a single `run(chat, args)` function.
+Full guide: `/doc flows`
+
+---
+
 ### Session controls
 
 | Command | Description |

1bcoder-0.1.8/_bcoder_data/agents/websearch.txt

@@ -0,0 +1,28 @@
+# Web search + fetch agent for capable models (4B+)
+# Usage: /agent websearch <question>
+description = Web research agent. Searches DuckDuckGo, fetches relevant pages, summarizes findings.
+max_turns = 10
+auto_exec = true
+auto_apply = true
+
+system =
+    You are a web research assistant. Search the web and fetch pages to answer the question.
+
+    To call a tool, write ACTION: on its own line followed by the command.
+    Wait for [tool result] before calling the next tool.
+    One ACTION per turn.
+    When done, write a clear summary answer. Do not write any ACTION when done.
+
+    Strategy:
+    1. Start with ACTION: /web search <question>
+    2. Review the search results (titles, URLs, snippets)
+    3. Pick the most relevant URLs and fetch them with ACTION: /web fetch <url>
+    4. Fetch up to 3 pages total — stop earlier if you already have enough to answer
+    5. Write a concise summary that directly answers the original question
+
+    Available tools:
+    {tool_list}
+
+tools =
+    web search
+    web fetch

{1bcoder-0.1.7 → 1bcoder-0.1.8}/_bcoder_data/aliases.txt

@@ -7,8 +7,10 @@
 /sqlite   = /agent sqlite
 /plan     = /agent planning
 /fill     = /agent fill
-/scan     = /agent scan {{args}}
-/compact  = /agent compact {{args}}
+/scan       = /agent scan {{args}}
+/compact    = /agent compact {{args}}
+/websearch  = /agent websearch {{args}}
+/webask     = /flow webask {{args}}
 
 /small    = /parallel {{args}}  profile: small
 /explain  = /parallel {{args}}  profile: explain

1bcoder-0.1.8/_bcoder_data/doc/FLOWS.md

@@ -0,0 +1,128 @@
+# Writing custom flows
+
+A **flow** is a Python file in `~/.1bcoder/flows/` (or `.1bcoder/flows/` for project-local).
+Run with `/flow <name> [args]`. List with `/flow list`.
+
+## Minimal template
+
+```python
+"""One-line description shown by /flow list. Usage: /flow myflow <args>"""
+
+
+def run(chat, args: str):
+    # 1. validate args
+    if not args.strip():
+        print("usage: /flow myflow <something>")
+        return
+
+    # 2. collect data
+    data = chat._agent_exec("/some command", auto_apply=True)
+
+    # 3. ask LLM in temp context
+    temp_msgs = [{"role": "system", "content": chat._role},
+                 {"role": "user",   "content": f"Your question:\n{data}"}]
+    chat._sep("AI")
+    reply = chat._stream_chat(temp_msgs)
+
+    # 4. inject only summary into main context
+    if reply:
+        chat.last_reply   = reply
+        chat._last_output = reply
+        chat.messages.append({"role": "user",      "content": "[myflow: label]"})
+        chat.messages.append({"role": "assistant", "content": reply})
+```
+
+## The four parts every flow has
+
+### 1. Validate args
+Check required input early and print usage if missing.
+
+### 2. Collect data
+Run commands, read files, call external tools — build the raw material for the LLM.
+The key rule: **collect as little as needed**. Prefer narrow searches first, fall back to broad ones.
+
+```python
+# narrow first, stop when you have something
+result = chat._agent_exec("/map find MyClass -d 2", auto_apply=True)
+if not result or "no matches" in result:
+    result = chat._agent_exec("/find MyClass -f", auto_apply=True)
+```
+
+### 3. Ask LLM in temporary context
+Always use `temp_msgs` — never append raw collected data to `chat.messages`.
+Raw data stays in temp context and is discarded after the LLM responds.
+
+```python
+temp_msgs = [{"role": "system", "content": chat._role},
+             {"role": "user",   "content": prompt}]
+reply = chat._stream_chat(temp_msgs)
+```
+
+### 4. Inject only the summary
+After the LLM replies, add a short label + the reply to main context.
+The raw data (which may be thousands of chars) never pollutes the conversation.
+
+```python
+chat.messages.append({"role": "user",      "content": "[myflow: label]"})
+chat.messages.append({"role": "assistant", "content": reply})
+```
+
+## chat object — what you can use
+
+| API | Description |
+|---|---|
+| `chat._agent_exec(cmd, auto_apply=True)` | Run any `/command`, return output as string |
+| `chat._stream_chat(messages)` | Send messages to LLM, stream output, return reply |
+| `chat._sep("AI")` | Print the `─── AI ───` separator before streaming |
+| `chat._role` | Current system persona string |
+| `chat.messages` | Main conversation history (append summary here) |
+| `chat.last_reply` | Last LLM reply — set this after your LLM call |
+| `chat._last_output` | Last output shown to user — set same as last_reply |
+| `chat._vars` | Session variables dict — read/write `{{varname}}` values |
+| `chat._web_ddg_search(term, n=8)` | DuckDuckGo search → list of (title, url, snippet) |
+| `chat._web_strip_html(bytes)` | Strip HTML tags from fetched page bytes |
+
+## Parsing args
+
+For simple flags use `re.search`:
+
+```python
+import re as _re
+
+n = 5
+m = _re.search(r"-n\s+(\d+)", args)
+if m:
+    n = int(m.group(1))
+    args = (args[:m.start()] + args[m.end():]).strip()
+```
+
+For file input with `-f`:
+
+```python
+m = _re.match(r"-f\s+(\S+)", args.strip())
+if m:
+    with open(m.group(1), encoding="utf-8") as f:
+        content = f.read()
+```
+
+## Prompt tips for small models (1b–3b)
+
+- Put the data **before** the question, not after
+- One direct question only — no rule lists
+- Short is better: `"Diff:\n{diff}\n\nWrite a one-line commit message."` beats ten bullet points
+
+## File location priority
+
+1. `.1bcoder/flows/` — project-local (highest priority, overrides others)
+2. `~/.1bcoder/flows/` — user global
+3. `_bcoder_data/flows/` — built-in defaults
+
+## Built-in flows as reference
+
+| Flow | Pattern |
+|---|---|
+| `webask` | external API (DDG) → loop fetch → temp LLM |
+| `grounding` | 1bcoder command → parse list → progressive loop search → temp LLM |
+| `simargl_files` | external tool via `/run` → parse list → loop `/read` → temp LLM |
+| `py_error_trace` | parse input text → loop file read at line → temp LLM |
+| `commit_message` | subprocess (git) → temp LLM |

1bcoder-0.1.8/_bcoder_data/flows/commit_message.py

@@ -0,0 +1,38 @@
+"""Generate a git commit message from staged or unstaged changes. Usage: /flow commit_message"""
+
+
+def run(chat, args: str):
+    import subprocess as _sp
+
+    def _git(cmd: list[str]) -> str:
+        try:
+            r = _sp.run(["git"] + cmd, capture_output=True, text=True, timeout=15)
+            return r.stdout.strip()
+        except Exception as e:
+            return f"(git error: {e})"
+
+    # prefer staged diff; fall back to unstaged
+    diff = _git(["diff", "--staged"])
+    diff_source = "staged changes"
+    if not diff:
+        diff = _git(["diff", "HEAD"])
+        diff_source = "unstaged changes"
+    if not diff:
+        print("[commit_message_generator] no changes found — run 'git add' to stage files first")
+        return
+
+    print(f"[commit_message_generator] generating from {diff_source} ({len(diff)} chars)")
+
+    prompt = (
+        f"Diff ({diff_source}):\n{diff[:6000]}\n\n"
+        f"Write a one-line git commit message describing what changed and why."
+    )
+    temp_msgs = [{"role": "system", "content": chat._role},
+                 {"role": "user",   "content": prompt}]
+    chat._sep("AI")
+    reply = chat._stream_chat(temp_msgs)
+    if reply:
+        chat.last_reply = reply
+        chat._last_output = reply
+        chat.messages.append({"role": "user",      "content": f"[commit_message: {diff_source}]"})
+        chat.messages.append({"role": "assistant", "content": reply})

1bcoder-0.1.8/_bcoder_data/flows/grounding.py

@@ -0,0 +1,106 @@
+"""Symbol grounding: extract codebase identifiers from task text, locate each progressively, summarize. Usage: /flow grounding <text>"""
+import re as _re
+
+
+def _parse_keywords(output: str) -> list[str]:
+    """Extract keyword list from /map keyword extract -c output (CSV on one line)."""
+    keywords = []
+    for token in _re.split(r"[,\n]+", output):
+        token = token.strip()
+        token = _re.sub(r"\(\d+\)$", "", token).strip()  # strip count suffix like "Name(12)"
+        if token and len(token) < 60 and " " not in token and not token.startswith("("):
+            keywords.append(token)
+    return keywords[:15]
+
+
+def _has_result(output: str) -> bool:
+    """Return True if the output contains a real match (not just a 'no matches' message)."""
+    if not output or output == "(no output)":
+        return False
+    no_match_patterns = ["no matches", "no match", "not found", "nothing found"]
+    low = output.lower()
+    return not any(p in low for p in no_match_patterns)
+
+
+def _search_keyword(chat, kw: str) -> str:
+    """
+    Progressive search for one keyword — stop as soon as we get a result:
+      1. /map find {kw} -d 2        — kw in filename, definitions only (no links)
+      2. /map find \\{kw} -d 2      — kw as identifier inside any block, definitions only
+      3. /find {kw} -c              — grep fallback (filenames + line counts)
+    """
+    # step 1: keyword in filename
+    out = chat._agent_exec(f"/map find {kw} -d 2", auto_apply=True).strip()
+    if _has_result(out):
+        return f"[filename match]\n{out}"
+
+    # step 2: keyword as identifier inside blocks
+    out = chat._agent_exec(f"/map find \\{kw} -d 2", auto_apply=True).strip()
+    if _has_result(out):
+        return f"[identifier match]\n{out}"
+
+    # step 3: grep by filename
+    out = chat._agent_exec(f"/find {kw} -f", auto_apply=True).strip()
+    if _has_result(out):
+        return f"[filename grep]\n{out}"
+
+    # step 4: grep by content — last resort, may be large
+    out = chat._agent_exec(f"/find {kw} -c", auto_apply=True).strip()
+    if _has_result(out):
+        return f"[content grep]\n{out}"
+
+    return ""
+
+
+def run(chat, args: str):
+    if not args.strip():
+        print("usage: /flow grounding <text or phrase>")
+        return
+
+    print(f"[grounding] extracting keywords from: {args}")
+    kw_output = chat._agent_exec(f"/map keyword extract {args} -c", auto_apply=True)
+    keywords = _parse_keywords(kw_output)
+    match_mode = "exact"
+
+    if not keywords:
+        print(f"[grounding] no exact keywords — trying fuzzy match...")
+        kw_output = chat._agent_exec(f"/map keyword extract {args} -f -c", auto_apply=True)
+        keywords = _parse_keywords(kw_output)
+        match_mode = "fuzzy"
+
+    if not keywords:
+        print(f"[grounding] no codebase keywords found — try /map keyword index first")
+        print(f"[grounding] raw: {repr(kw_output[:200])}")
+        return
+
+    print(f"[grounding] found {len(keywords)} keyword(s) [{match_mode}]: {', '.join(keywords)}")
+
+    sections = []
+    for kw in keywords:
+        result = _search_keyword(chat, kw)
+        if result:
+            sections.append(f"### {kw}\n{result}")
+        else:
+            print(f"[grounding] no hits for: {kw}")
+
+    if not sections:
+        print("[grounding] no hits found for any keyword")
+        return
+
+    combined = "\n\n".join(sections)
+    prompt = (
+        f"Task description: {args}\n\n"
+        f"Below are keyword search results from the codebase.\n"
+        f"Based on these results, list the specific files where the implementation "
+        f"of this task most likely resides. For each file explain in one sentence why.\n\n"
+        f"{combined}"
+    )
+    temp_msgs = [{"role": "system", "content": chat._role},
+                 {"role": "user",   "content": prompt}]
+    chat._sep("AI")
+    reply = chat._stream_chat(temp_msgs)
+    if reply:
+        chat.last_reply = reply
+        chat._last_output = reply
+        chat.messages.append({"role": "user",      "content": f"[grounding: {args}]"})
+        chat.messages.append({"role": "assistant", "content": reply})

1bcoder-0.1.8/_bcoder_data/flows/py_error_trace.py

@@ -0,0 +1,87 @@
+"""Analyse a Python traceback: extract file:line locations, read code context, explain the error. Usage: /flow py_error_trace [-f <file>]"""
+import re as _re
+import os as _os
+
+
+def _extract_locations(traceback: str) -> list[tuple[str, int]]:
+    """Extract (filepath, lineno) pairs from a Python traceback."""
+    locations = []
+    seen = set()
+    for m in _re.finditer(r'File "([^"]+)", line (\d+)', traceback):
+        path, line = m.group(1), int(m.group(2))
+        # skip stdlib and site-packages
+        norm = path.replace("\\", "/")
+        if any(x in norm for x in ("/lib/", "site-packages", "<frozen", "<string")):
+            continue
+        key = (norm, line)
+        if key not in seen:
+            seen.add(key)
+            locations.append((path, line))
+    return locations
+
+
+def _read_context(path: str, lineno: int, context: int = 10) -> str:
+    """Read lines around lineno from file."""
+    try:
+        with open(path, encoding="utf-8", errors="replace") as f:
+            lines = f.readlines()
+        start = max(0, lineno - context - 1)
+        end   = min(len(lines), lineno + context)
+        numbered = []
+        for i, l in enumerate(lines[start:end], start=start+1):
+            marker = ">>>" if i == lineno else "   "
+            numbered.append(f"{marker} {i:4d} | {l.rstrip()}")
+        return "\n".join(numbered)
+    except OSError:
+        return f"(could not read {path})"
+
+
+def run(chat, args: str):
+    # resolve traceback source: -f <file>, empty → last_reply, else inline args
+    traceback_text = ""
+    m = _re.match(r"-f\s+(\S+)", args.strip())
+    if m:
+        fpath = m.group(1)
+        try:
+            with open(fpath, encoding="utf-8", errors="replace") as f:
+                traceback_text = f.read()
+            print(f"[py_error_trace] reading traceback from {fpath}")
+        except OSError as e:
+            print(f"[py_error_trace] cannot read file: {e}"); return
+    elif args.strip():
+        traceback_text = args
+    else:
+        traceback_text = chat._last_output
+        if not traceback_text:
+            print("usage: /flow py_error_trace [-f <file>]  (or run a command first with /run)")
+            return
+        print(f"[py_error_trace] using last /run output as traceback")
+
+    locations = _extract_locations(traceback_text)
+    if not locations:
+        print("[py_error_trace] no file:line references found in traceback")
+        return
+
+    print(f"[py_error_trace] found {len(locations)} location(s)")
+
+    sections = [f"## Traceback\n```\n{traceback_text.strip()}\n```"]
+    for path, lineno in locations:
+        print(f"[py_error_trace] reading {path}:{lineno}")
+        code_ctx = _read_context(path, lineno)
+        sections.append(f"## {path} (line {lineno})\n```python\n{code_ctx}\n```")
+
+    combined = "\n\n".join(sections)
+    prompt = (
+        f"Analyse this Python error traceback and the relevant code locations.\n"
+        f"Explain: what caused the error, which line is the root cause, and what needs to be fixed.\n\n"
+        f"{combined}"
+    )
+    temp_msgs = [{"role": "system", "content": chat._role},
+                 {"role": "user",   "content": prompt}]
+    chat._sep("AI")
+    reply = chat._stream_chat(temp_msgs)
+    if reply:
+        chat.last_reply = reply
+        chat._last_output = reply
+        chat.messages.append({"role": "user",      "content": "[py_error_trace]"})
+        chat.messages.append({"role": "assistant", "content": reply})

1bcoder-0.1.8/_bcoder_data/flows/simargl_files.py

@@ -0,0 +1,66 @@
+"""Run simargl task retrieval, read top N matched files, summarize relevance. Usage: /flow simargl_files <task description> [-n N]"""
+import re as _re
+import os as _os
+
+
+def _parse_file_paths(output: str) -> list[str]:
+    """Extract file paths from simargl output lines like '0.82  src/foo/bar.py'."""
+    paths = []
+    for line in output.splitlines():
+        line = line.strip()
+        # match lines: optional score + path with extension
+        m = _re.match(r"(?:[\d.]+\s+)?(\S+\.\w+)$", line)
+        if m:
+            paths.append(m.group(1))
+    return paths
+
+
+def run(chat, args: str):
+    max_files = 5
+    m = _re.search(r"-n\s+(\d+)", args)
+    if m:
+        max_files = int(m.group(1))
+        args = (args[:m.start()] + args[m.end():]).strip()
+    task = args.strip()
+    if not task:
+        print('usage: /flow simargl_files <task description> [-n N]')
+        return
+
+    print(f"[simargl_files] querying simargl for: {task}")
+    simargl_output = chat._agent_exec(f'/run simargl search --mode task --sort rank "{task}"', auto_apply=True)
+    file_paths = _parse_file_paths(simargl_output)
+
+    if not file_paths:
+        print("[simargl_files] no file paths found in simargl output")
+        return
+
+    file_paths = file_paths[:max_files]
+    print(f"[simargl_files] reading {len(file_paths)} file(s): {', '.join(file_paths)}")
+
+    sections = []
+    for path in file_paths:
+        content = chat._agent_exec(f"/read {path}", auto_apply=True).strip()
+        if content:
+            sections.append(f"### {path}\n{content}")
+        else:
+            print(f"[simargl_files] could not read {path}")
+
+    if not sections:
+        print("[simargl_files] no file content retrieved")
+        return
+
+    combined = "\n\n".join(sections)
+    prompt = (
+        f"Given the following task description:\n{task}\n\n"
+        f"And the following relevant source files:\n\n{combined}\n\n"
+        f"Explain what changes would be needed and in which files."
+    )
+    temp_msgs = [{"role": "system", "content": chat._role},
+                 {"role": "user",   "content": prompt}]
+    chat._sep("AI")
+    reply = chat._stream_chat(temp_msgs)
+    if reply:
+        chat.last_reply = reply
+        chat._last_output = reply
+        chat.messages.append({"role": "user",      "content": f"[simargl_files: {task}]"})
+        chat.messages.append({"role": "assistant", "content": reply})