localcode 0.3.13__tar.gz → 0.3.15__tar.gz

{localcode-0.3.13/src/localcode.egg-info → localcode-0.3.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.3.13
+Version: 0.3.15
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.3.13 → localcode-0.3.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "localcode"
-version = "0.3.13"
+version = "0.3.15"
 description = "High-performance AI coding on consumer hardware."
 readme = "README.md"
 requires-python = ">=3.10"

{localcode-0.3.13 → localcode-0.3.15}/src/localcode/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.3.13"
+__version__ = "0.3.15"

{localcode-0.3.13 → localcode-0.3.15}/src/localcode/agent/context.py

@@ -771,6 +771,32 @@ def build_progress_ledger(
     return head + ("\n" + extra if extra else "")
 
 
+_PROJECT_MARKERS = ("package.json", "pyproject.toml", ".git", "go.mod", "Cargo.toml", "tsconfig.json")
+
+
+def _project_root_for(common: str, dirs: list[str]) -> str | None:
+    """The project directory to scan: the nearest marker at-or-below `common`,
+    else the deepest single changed-file dir. Bounds the walk to one project."""
+    import os
+    # Walk DOWN from each changed dir toward `common` looking for a marker,
+    # picking the shallowest marker that is still within `common`.
+    candidates = []
+    for d in dirs:
+        cur = d
+        while cur and cur.startswith(common):
+            if any(os.path.exists(os.path.join(cur, m)) for m in _PROJECT_MARKERS):
+                candidates.append(cur)
+            parent = os.path.dirname(cur)
+            if parent == cur:
+                break
+            cur = parent
+    if candidates:
+        return min(candidates, key=len)  # shallowest marker dir
+    # No marker: only trust it if all changed files share ONE dir (a real
+    # single-project build); otherwise decline (common ancestor may be broad).
+    return dirs[0] if len(set(dirs)) == 1 else None
+
+
 def build_filesystem_state(changed_files: list[str], max_files: int = 80) -> str:
     """Ground-truth 'what's actually on disk' for the project being built.
 
@@ -786,13 +812,24 @@ def build_filesystem_state(changed_files: list[str], max_files: int = 80) -> str
     roots = [os.path.dirname(f) for f in changed_files if f]
     if not roots:
         return ""
-    # Project root = shortest existing common-ish ancestor of changed files.
     try:
-        root = os.path.commonpath([os.path.abspath(os.path.dirname(f))
-                                   for f in changed_files if f])
+        common = os.path.commonpath([os.path.abspath(os.path.dirname(f))
+                                     for f in changed_files if f])
     except Exception:
-        root = os.path.abspath(roots[0])
-    if not os.path.isdir(root):
+        common = os.path.abspath(roots[0])
+    # SCOPE GUARD: only ever walk a real PROJECT dir, never a broad ancestor
+    # like ~ or a top-level workspace. Anchor to the nearest project marker
+    # (package.json / pyproject.toml / .git / go.mod / Cargo.toml) at-or-below
+    # the common path; if none, use the deepest single changed-file dir. And
+    # NEVER walk the home dir or anything shallower — bail out entirely.
+    root = _project_root_for(common, [os.path.abspath(os.path.dirname(f))
+                                      for f in changed_files if f])
+    home = os.path.expanduser("~")
+    if not root or not os.path.isdir(root):
+        return ""
+    if os.path.abspath(root) in (home, os.path.dirname(home), os.path.sep):
+        return ""
+    if len(os.path.abspath(root).rstrip("/").split("/")) < 4:  # too shallow → unsafe to walk
         return ""
     _SKIP = {".git", "node_modules", "dist", "build", ".venv", "__pycache__", ".next"}
     _SRC = (".ts", ".tsx", ".js", ".jsx", ".py", ".css", ".scss", ".html", ".json",
@@ -863,50 +900,67 @@ def _compact_messages(messages: list[dict], out: "OutputManager") -> list[dict]:
     if not old:
         return messages
 
-    # Build summary from old messages
-    parts = []
-    files_modified = set()
-    commands_run = []
+    # Build an anchored "Work State" summary from old messages. This is the
+    # structure opencode + codex converge on (Objective / Completed / Blocked /
+    # Next Move) — a state machine a small local model can follow, not a flat
+    # "Called X, Called Y" log. Built DETERMINISTICALLY (no LLM call — matches
+    # codex's no-inference compaction, which matters on slow 16GB hardware):
+    # completed = files written + commands that succeeded; blocked = commands
+    # that failed / errors; objective = the first user request.
+    objective = ""
+    files_modified: list[str] = []
+    ok_cmds: list[str] = []
+    failed: list[str] = []
 
     for m in old:
         role = m.get("role", "")
         content = str(m.get("content", ""))
-
+        if role == "user" and not objective and not content.startswith(("Previous", "SYSTEM:", "##")):
+            objective = content[:200]
         if role == "assistant" and m.get("tool_calls"):
             for tc in m["tool_calls"]:
                 fn = tc.get("function", {})
                 name = fn.get("name", "")
                 try:
-                    # `arguments` may be a JSON string OR an already-decoded
-                    # dict (some providers/parsers do that) — json.loads on a
-                    # dict raises TypeError, which used to escape and kill the
-                    # turn with E3102 during compaction.
                     _raw = fn.get("arguments", "{}")
                     args = _raw if isinstance(_raw, dict) else json.loads(_raw)
                 except (json.JSONDecodeError, TypeError, ValueError):
                     args = {}
-                if name in ("write_file", "append_file", "edit_file"):
-                    files_modified.add(args.get("path", "?"))
+                if name in ("write_file", "append_file", "edit_file", "multi_edit"):
+                    p = args.get("path") or args.get("file_path")
+                    if p and p not in files_modified:
+                        files_modified.append(p)
                 elif name == "bash":
-                    commands_run.append(args.get("command", "")[:60])
-                parts.append(f"Called {name}({_summarize_args(args)})")
+                    ok_cmds.append(str(args.get("command", ""))[:70])
+        elif role == "tool":
+            c = content.strip()
+            if c.startswith(("Error", "[exit code", "REJECTED")) or "Traceback " in c:
+                failed.append(c.splitlines()[0][:100] if c else "")
 
-        elif role == "user" and not content.startswith("Previous"):
-            parts.append(f"User: {content[:100]}")
-
-    summary_lines = ["Previous conversation summary:"]
+    completed = []
     if files_modified:
-        summary_lines.append(f"Files modified: {', '.join(files_modified)}")
-    if commands_run:
-        summary_lines.append(f"Commands run: {'; '.join(commands_run[:5])}")
-    summary_lines.extend(parts[-8:])
-
-    out.print_info("Context compacted — older messages summarized.")
+        completed.append("Files created/edited: " + ", ".join(files_modified))
+    if ok_cmds:
+        completed.append("Commands run: " + " | ".join(ok_cmds[-5:]))
+    blocked = [f for f in failed if f][-3:]
+
+    lines = ["## Work state so far (older turns compacted — build on this, don't redo it):"]
+    if objective:
+        lines.append(f"Objective: {objective}")
+    lines.append("Completed:")
+    lines.extend(f"  - {c}" for c in completed) if completed else lines.append("  - (none yet)")
+    if blocked:
+        lines.append("Blocked / errors seen:")
+        lines.extend(f"  - {b}" for b in blocked)
+    lines.append("Next move: continue the objective from the current file state; "
+                 "do not re-read files or re-run commands listed above.")
+
+    out.print_info("Context compacted — older turns summarized to a work-state note.")
 
     return [
         *system,
-        {"role": "user", "content": "\n".join(summary_lines)},
-        {"role": "assistant", "content": "Got it. Continuing from where we left off."},
+        {"role": "user", "content": "\n".join(lines)},
+        {"role": "assistant", "content": "Understood — continuing from the current state."},
         *recent,
     ]
 

{localcode-0.3.13 → localcode-0.3.15}/src/localcode/agent/prompt_context.py

@@ -19,85 +19,11 @@ __all__ = [
     "build_agent_system_prompt",
     "build_task_goal_block",
     "build_dynamic_skills_block",
-    "is_placeholder_segment",
-    "sanitize_placeholder_path",
     "build_target_grounding_block",
     "build_incremental_milestones_block",
 ]
 
 
-# A path segment the model emitted as a literal fill-in-the-blank prompt
-# rather than a real name. Observed in a real build failure: the model
-# wrote a target path containing "[insert your model name]" verbatim and
-# then thrashed because that directory could never resolve. We catch the
-# common bracketed/angle-bracketed/braced placeholder shapes plus the
-# bare "your-..." / "my-..." conventions LLMs reach for.
-_PLACEHOLDER_RE = re.compile(
-    r"""
-    ^\s*(?:
-        [\[\<\{].*?[\]\>\}]            # [insert x] / <your x> / {name}
-      | (?:insert|your|my|the)[\s_-]+  # "insert ...", "your ...", "my ..."
-        (?:\w+[\s_-]*)*?               # the words being filled in
-        (?:name|here|project|app|dir|folder|path|model)\b
-      | (?:project[\s_-]*name|app[\s_-]*name|model[\s_-]*name|placeholder)
-      | \.{3,}                         # literal "..."
-      | xxx+|tbd|todo
-    )\s*$
-    """,
-    re.IGNORECASE | re.VERBOSE,
-)
-
-
-def is_placeholder_segment(segment: str) -> bool:
-    """True if a single path segment looks like an unfilled placeholder
-    (e.g. "[insert your model name]", "<your app>", "project-name",
-    "...", "TODO") rather than a concrete name the model chose.
-    """
-    seg = str(segment or "").strip()
-    if not seg:
-        return False
-    return bool(_PLACEHOLDER_RE.match(seg))
-
-
-def sanitize_placeholder_path(path: str, default_name: str = "app") -> str:
-    """Replace any placeholder segments in `path` with a concrete name.
-
-    The model sometimes emits a target path with a literal fill-in slot
-    ("./[insert your model name]/main.py"). Such a path can never resolve,
-    so the build thrashes. We substitute a sensible default for each
-    placeholder segment so the path is at least concrete; the grounding
-    block (see `build_target_grounding_block`) separately instructs the
-    model to choose a real name. `default_name` is sanitized to a safe
-    slug; falls back to "app" when empty.
-
-    Returns the original string unchanged when no placeholder is present
-    (the common case — keeps real paths byte-identical).
-    """
-    raw = str(path or "")
-    if not raw:
-        return raw
-    safe_default = re.sub(r"[^A-Za-z0-9._-]+", "-", str(default_name or "").strip()).strip("-")
-    if not safe_default:
-        safe_default = "app"
-    # Preserve a leading "./" or "/" and split on the OS separator without
-    # collapsing it, so we can rejoin with the same separator.
-    sep = "/"
-    if "\\" in raw and "/" not in raw:
-        sep = "\\"
-    segments = raw.split(sep)
-    changed = False
-    out_segments: list[str] = []
-    for seg in segments:
-        if is_placeholder_segment(seg):
-            out_segments.append(safe_default)
-            changed = True
-        else:
-            out_segments.append(seg)
-    if not changed:
-        return raw
-    return sep.join(out_segments)
-
-
 @dataclass
 class PromptBuildResult:
     system_prompt: str
@@ -183,11 +109,9 @@ def build_agent_system_prompt(
 def build_target_grounding_block(repo_root: Any, goal_state: Any) -> str:
     """One short block that pins the target directory for build-type turns.
 
-    Grounds the model so it stops thrashing between the repo root and a
-    subdir, and explicitly forbids literal placeholder path segments
-    ("[insert your model name]", "<your app>") — substitute a real name
-    instead. Returned only for build_app-shaped goals; empty otherwise so
-    the cached prompt prefix is unaffected for ordinary turns.
+    Grounds the model so it stops thrashing between the repo root and a subdir.
+    Returned only for build_app-shaped goals; empty otherwise so the cached
+    prompt prefix is unaffected for ordinary turns.
     """
     goal_type = str(getattr(goal_state, "goal_type", "") or "")
     if goal_type != "build_app":
@@ -198,20 +122,11 @@ def build_target_grounding_block(repo_root: Any, goal_state: Any) -> str:
         root = str(repo_root or "")
     if not root:
         return ""
-    suggested = str(getattr(goal_state, "task_slug", "") or "").strip()
-    name_hint = (
-        f' If you create a new subdirectory, pick a concrete name (e.g. "{suggested}") —'
-        if suggested
-        else " If you create a new subdirectory, pick a concrete, descriptive name —"
-    )
     return (
         "\n\nTarget location (work here, do not drift):\n"
         f"- The project root is: {root}\n"
         "- Create and edit all files under that root. Do not switch between the "
         "root and an unrelated subdirectory between steps; decide once and stay there.\n"
-        "- NEVER write a path containing a literal placeholder such as "
-        "`[insert your model name]`, `<your app>`, `{project-name}`, or `...`."
-        f"{name_hint} never leave the placeholder text in the path.\n"
     )
 
 

{localcode-0.3.13 → localcode-0.3.15}/src/localcode/agent/prompts.py

@@ -13,7 +13,6 @@ from .constants import PROJECT_FILES as _PROJECT_FILES
 
 __all__ = [
     "SYSTEM_PROMPT",
-    "SYSTEM_PROMPT_V2",
     "REASONING_RULES",
     "model_identity_line",
     "project_stack_line",
@@ -40,61 +39,21 @@ _STACK_MARKERS: tuple[tuple[str, str], ...] = (
 
 
 SYSTEM_PROMPT = """\
-You are LocalCode, a coding agent on the user's machine with full filesystem access.
-
-Available tools: read_file, write_file, append_file, edit_file, bash, list_files, todo_write.
-
-How to work:
-- Match scope to the request. Answer plain questions plainly. Build what was asked when asked. Don't write a script when a one-line bash command will do.
-- Cover every requirement the user named. If your chosen approach can't deliver one, change the approach — don't drop the requirement to fit the approach.
-- PLAN MULTI-STEP WORK. For any task with 3+ steps, call `todo_write` FIRST to lay out the steps, then keep it current: mark exactly ONE item in_progress before you start it, and mark it completed the instant it's done. Your task list is shown back to you every round — read it to see what's already finished and what's left, so you advance to the next step instead of redoing one you've already done. If you catch yourself about to re-read a file or re-run a command you ran before, check the list: you've likely already done it.
-- If the request is ambiguous in a way that affects your approach (stack, interface, scope), ask one short question before building, not after.
-- ACT, DON'T NARRATE. Every "let me read", "let me fix", "now I'll write" MUST be followed by the actual tool call IN THE SAME TURN. If you say "let me write the fix" and then end your turn without calling edit_file or write_file, you have failed the user. The user has explicitly complained about this. Never describe a fix without immediately performing it.
-- Forbidden patterns: "Let me read the file:" + end of turn. "I'll rewrite this:" + end of turn. "Now I'll apply the fix:" + end of turn. If the next thing out of your mouth is a verb of intent, the very next action MUST be the tool call that delivers on that intent.
-- One short sentence (≤12 words) per tool call MAX. No multi-sentence preambles. No "let me plan" before acting.
-- Use real, repo-relative paths. Don't improvise `/Users/...` paths unless the user gave one.
-- Write complete code. No TODOs, stubs, fake data, empty dirs, or skeleton files. Never end with "should I do X or Y next?" — once started, finish.
-- Execute every named requirement in this turn until 100% complete. If a piece is too large for one tool call, split across more — never drop it. Never declare a requirement out of scope, over the limit, or needing external assets.
-- MATCH THE PROJECT'S LANGUAGE AND CONVENTIONS. Code MUST be valid for the file's actual language. Never write Python syntax (triple-quoted docstrings, snake_case, `import x`/`from x import y`) in a .ts/.tsx/.js/.jsx/.go/.rs or other non-Python file. Use that language's real comment, naming, and import/module syntax, and mirror the patterns already present in the project (imports, formatting, framework idioms).
-- For new projects, create a small multi-file structure by default. Keep entrypoints thin; move reusable logic, styles, data/config, templates, and assets into focused files. Use one large file only if requested.
-- Prefer edit_file for existing files. Use write_file when creating a new file or doing a deliberate full rewrite.
-- When a tool returns an error, read it, fix the specific problem, and retry with DIFFERENT input. Never repeat an identical failing call: if the same call fails or returns the same result twice, change the arguments or the approach, or move on — do not loop. Don't give up after one failed call, but don't spin on it either.
-- DON'T RE-READ OR RE-SEARCH what you already have. If you already read a file this turn and it hasn't changed, the content is still above — use it, don't read it again. If a search already gave you a useful result, act on it (open the match, make the edit); don't run the same search again. Repeating a read/search you've already done is the #1 way turns stall.
-- After a tool result, CONTINUE from where you left off — don't restate what you just did or re-summarize the plan. Take the next concrete action.
-- DON'T CONFABULATE. If the user names a person, song, place, term, library, command, or concept you do not recognize, your FIRST move is to say "I don't recognize that" — NOT to invent a plausible-sounding meaning by phonetic association. Phonetic fits ("Alombasi sounds Bantu so it must be a Zambian chant", "Pyfoo sounds like a Python library so it must do X") are exactly the failure mode. If a web search would help, run it BEFORE asserting facts; if results are empty, say so plainly. Never write paragraph-length cultural/etymological/technical descriptions of something you can't actually source — "I'd love to know more, what's it from?" is the correct answer. Doubling down when the user repeats the unknown term is also forbidden; repetition is not evidence.
-
-Runtime facts (true today; rely on these instead of guessing):
-- write_file creates a new file or fully overwrites an existing one. There is no separate "rewrite" tool.
-- edit_file matches `old_string` with whitespace tolerance; if it can't find the match, it lists the 3 closest lines. Use 2–4 adjacent lines as the anchor — that's almost always unique.
-- read_file output is line-prefixed with `<digit>\\t`; edit_file strips that prefix automatically when you copy lines back as `old_string`.
-- bash returns an exit code; non-zero means the command failed. Background long-running processes (`cmd &` or `nohup cmd &`) so bash returns.
-- The runtime redacts bulky payloads from older turns to save context. If you need that content again, call read_file on the path — the file is still on disk.
-
-Working directory: {cwd}
-{network_status}{reasoning_rules}{project_instructions}{skills_block}"""
-
-
-# Leaner, front-loaded variant tuned for SMALL local models. ~40% shorter
-# than SYSTEM_PROMPT: top rules first, redundancy cut (the 3× act-don't-
-# narrate and the 200-word confabulation paragraph are condensed), the stale
-# 6-item "Available tools" line dropped (the real tool list is delivered by
-# the runtime). Same placeholder slots + cwd/network at the tail to preserve
-# the prefix cache. NOT yet the live default — A/B'd against SYSTEM_PROMPT on
-# the real models before any swap (see scripts/bench_prompt_variants.py).
-SYSTEM_PROMPT_V2 = """\
 You are LocalCode, a coding agent running locally on the user's machine with full filesystem access through your tools.
 
 Top rules (most important first):
-1. ACT, DON'T NARRATE. If you say "let me read/fix/write X", the tool call that does it MUST come next, in the same turn. Never end a turn on a statement of intent.
+1. ACT, DON'T NARRATE. If you say "let me read/fix/write X", the tool call that does it MUST come next, in the same turn. Never end a turn on a statement of intent. At most one short sentence of preamble per tool call.
 2. FINISH THE JOB. Cover every requirement the user named. Write complete, runnable code — no TODOs, stubs, placeholders, or "should I do X next?". If a piece is too big for one call, split it across calls; never drop it.
-3. MATCH SCOPE. Answer plain questions plainly; build only what was asked. Don't write a script when one bash line does it. At most one short sentence of preamble per tool call.
-4. DON'T INVENT. If you don't recognize a term, library, or command, say so — never guess a plausible meaning. Search the web before asserting facts; if results are empty, say that.
+3. MATCH SCOPE. Answer plain questions plainly; build only what was asked. Don't write a script when one bash line does it.
+4. DON'T REPEAT WORK. Don't re-read a file or re-run a command you already did — the result is still above. After a tool result, continue from where you left off; don't restate the plan.
+5. DON'T INVENT. If you don't recognize a term, library, or command, say so — never guess a plausible meaning. Search the web before asserting facts; if results are empty, say that.
 
-Files & tools:
+Plan & tools:
+- For a task with 3+ steps, call todo_write first to lay out the steps, then keep exactly one in_progress and mark each done the instant it's finished. Your list is shown back each round — use it to see what's left.
 - Use real, repo-relative paths (don't improvise `/Users/...` paths).
 - edit_file for existing files: anchor `old_string` on 2–4 adjacent lines (matching is whitespace-tolerant; the leading `<n>\\t` from read_file is stripped for you). write_file to create or fully rewrite.
-- On a tool error, read it, fix the specific cause, and retry — don't give up after one failure.
-- New project → prefer a small multi-file layout with a thin entrypoint.
+- On a tool error, read it, fix the specific cause, and retry — don't give up after one failure, and don't repeat the same failing call.
+- New project → prefer a small multi-file layout with a thin entrypoint. Write code valid for the file's real language and match the project's existing conventions.
 
 Runtime facts:
 - bash returns an exit code; non-zero = failure. Background long-running commands (`cmd &`) so bash returns.
@@ -106,6 +65,7 @@ Working directory: {cwd}
 {network_status}{reasoning_rules}{project_instructions}{skills_block}"""
 
 
+
 # Reasoning-mode appendix. Injected into `SYSTEM_PROMPT` only when the
 # user is in a `-think` runtime mode (see `use_thinking` at the agent
 # entry). In fast mode the placeholder collapses to an empty string so
@@ -171,11 +131,10 @@ def model_identity_line(model: str) -> str:
         f"the work: take the next action directly. Only state your name if the "
         f"user explicitly asks who you are. "
         f"The model currently powering you is \"{friendly}\". Report it as EXACTLY "
-        f"\"{friendly}\" when the user asks which model/version/quant you are. And "
-        f"when the task asks you to name a file/folder/project after your model "
-        f"(e.g. a path like `.../[insert your model name]`), USE \"{friendly}\" as "
-        f"that name and create it — do NOT skip it or substitute 'LocalCode'. Never "
-        f"say you are unsure and never name a different model or provider.\n"
+        f"\"{friendly}\" when the user asks which model/version/quant you are, or "
+        f"when the task asks you to name a file/folder/project after your model — "
+        f"in that case use \"{friendly}\" as the name and create it. Never say you "
+        f"are unsure and never name a different model or provider.\n"
     )
 
 

{localcode-0.3.13 → localcode-0.3.15}/src/localcode/runtime.py

@@ -1130,7 +1130,7 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
             # loop. Without them (llama.cpp's default breakers don't include
             # path chars), a path repeated within one round — `cd X && mkdir X
             # && ls X` — got its username subtokens suppressed and the model
-            # emitted mangled variants (`marcsolomon` → `marcolon`). Breaking on
+            # emitted mangled variants of the home-dir username. Breaking on
             # `/ . _ - space` keeps DRY for phrasal loops but frees paths/idents.
             "dry_sequence_breakers": ["\n", "/", ".", "_", "-", " ", ":", "\"", "'"],
         }

{localcode-0.3.13 → localcode-0.3.15}/src/localcode/tools/bash.py

@@ -699,9 +699,9 @@ def _normalize_repo_root_variants(cmd: str, repo: str) -> str:
     appear and clearly target this repo, normalize them to the actual root
     instead of letting the command fail for a fake home-directory variant.
     Then a general pass repairs ANY `/Users/<garbled>/` (not just repo paths)
-    back to the real home — the model mangles the username via penalty-induced
-    token corruption (`marcsolomon` → `marcolon`/`marcslomon`), a DIFFERENT
-    misspelling each time, so it can't be dedup'd; we fix it deterministically.
+    back to the real home — the model mangles the home-dir username via
+    penalty-induced token corruption (a DIFFERENT misspelling each time, so it
+    can't be dedup'd); we fix it deterministically against the real $HOME.
     """
     if not repo.startswith("/Users/"):
         return _repair_home_username(cmd)

{localcode-0.3.13 → localcode-0.3.15}/src/localcode/tools/read_file.py

@@ -72,7 +72,7 @@ def execute(ctx: ToolContext, args: dict) -> str:
         return "Error: 'path' argument is required for read_file."
     path = ctx.repo / args["path"]
     if not path.exists():
-        # A small model invents misspelled/wrong-case paths ("Aki" for "Anki",
+        # A small model invents misspelled/wrong-case paths (a dropped letter,
         # gitHub/github/Github) and, getting a bare "not found", retries with
         # ANOTHER wrong variant forever (dedup can't collapse differing typos).
         # Point it at the real nearby file so it corrects instead of guessing.

{localcode-0.3.13 → localcode-0.3.15}/src/localcode/tools/write_file.py

@@ -188,7 +188,7 @@ def execute(ctx: ToolContext, args: dict) -> str:
 
     existed = path.is_file()
     # Typo-duplicate guard: creating a NEW file whose name closely matches an
-    # existing sibling (e.g. `ReivewSession.tsx` next to `ReviewSession.tsx`)
+    # existing sibling (a one-letter-off variant of a file that already exists)
     # is almost always a filename typo that splits the code across two files
     # and breaks imports. Warn before it snowballs. (Observed in real logs.)
     _dup_warning = ""

{localcode-0.3.13 → localcode-0.3.15/src/localcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.3.13
+Version: 0.3.15
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.3.13 → localcode-0.3.15}/tests/test_agent_event_regressions.py

@@ -7,8 +7,6 @@ from localcode.agent.prompt_context import (
     build_incremental_milestones_block,
     build_target_grounding_block,
     build_task_goal_block,
-    is_placeholder_segment,
-    sanitize_placeholder_path,
 )
 from localcode.launcher import detect_launch_candidate
 from localcode.process_registry import (
@@ -519,52 +517,18 @@ def test_build_app_goal_block_is_empty() -> None:
     assert build_task_goal_block("build a small dashboard app", goal, task) == ""
 
 
-def test_placeholder_segment_detection() -> None:
-    # Literal fill-in slots the model should never leave in a path.
-    for seg in (
-        "[insert your model name]",
-        "<your app>",
-        "{project-name}",
-        "project-name",
-        "app_name",
-        "model name",
-        "...",
-        "TODO",
-        "xxxx",
-    ):
-        assert is_placeholder_segment(seg), seg
-    # Real, concrete names must NOT be flagged.
-    for seg in ("src", "my-dashboard", "app.py", "weather_cli", "v2", "README.md"):
-        assert not is_placeholder_segment(seg), seg
-
-
-def test_sanitize_placeholder_path_substitutes_default() -> None:
-    # Placeholder segment is replaced; the rest of the path is preserved.
-    assert (
-        sanitize_placeholder_path("./[insert your model name]/main.py", "weather-cli")
-        == "./weather-cli/main.py"
-    )
-    # An unsafe default name is slugged.
-    assert (
-        sanitize_placeholder_path("<your app>/index.html", "My Cool App!")
-        == "My-Cool-App/index.html"
-    )
-    # A concrete path is returned byte-identical (no spurious rewriting).
-    assert sanitize_placeholder_path("src/server/app.py", "x") == "src/server/app.py"
-    # Empty / missing default falls back to "app".
-    assert sanitize_placeholder_path("[insert name]/x.py", "") == "app/x.py"
+# (Removed: the path-placeholder detection/substitution feature — trying to
+# regex every placeholder shape a user might write was task-specific bloat.)
 
 
 class _BuildGoal:
     goal_type = "build_app"
-    task_slug = "weather-dashboard"
+    task_slug = "demo"
 
 
-def test_target_grounding_block_pins_root_and_forbids_placeholders(tmp_path: Path) -> None:
+def test_target_grounding_block_pins_project_root(tmp_path: Path) -> None:
     block = build_target_grounding_block(tmp_path, _BuildGoal())
-    assert str(tmp_path.resolve()) in block
-    assert "placeholder" in block.lower()
-    assert "weather-dashboard" in block  # suggested concrete name
+    assert str(tmp_path.resolve()) in block  # grounds the model to the project root
     # Non-build goals get no block (keeps the cached prefix unchanged).
     assert build_target_grounding_block(tmp_path, infer_goal_state("what is 2+2")) == ""
 

{localcode-0.3.13 → localcode-0.3.15}/tests/test_prompt_language_steering.py

@@ -14,12 +14,11 @@ from localcode.agent.prompts import SYSTEM_PROMPT, project_stack_line
 
 def test_system_prompt_has_language_matching_rule() -> None:
     text = SYSTEM_PROMPT.lower()
-    # The rule must forbid Python syntax leaking into other languages and
-    # tell the model to match the file's actual language + conventions.
-    assert "match the project's language" in text
-    assert "triple-quoted docstrings" in text
-    assert "snake_case" in SYSTEM_PROMPT
-    assert ".tsx" in SYSTEM_PROMPT
+    # The prompt must tell the model to write code valid for the file's actual
+    # language and match the project's conventions (worded concisely — no long
+    # per-language example list, which bloats the prompt for a small model).
+    assert "valid for the file's real language" in text
+    assert "match the project's existing conventions" in text
     assert "conventions" in text