lcode-cli 0.34.0__py3-none-any.whl → 0.35.1__py3-none-any.whl

lcode/__init__.py

@@ -3,7 +3,7 @@
 From a program: `from lcode import Session` (see lcode.api).
 """
 
-__version__ = "0.34.0"
+__version__ = "0.35.1"
 
 API = ("Session", "Result", "Options", "SetupError")
 

lcode/agent.py

@@ -29,6 +29,7 @@ from lcode import (
     catalog,
     checks,
     codesearch,
+    escalate,
     extensions,
     limits,
     notify,
@@ -50,7 +51,7 @@ from lcode.mcp import McpManager
 from lcode.ollama import Ollama, OllamaError
 from lcode.permissions import LEADING_CD, Permissions
 from lcode.render import MarkdownStreamer
-from lcode.repeats import Repeats
+from lcode.repeats import Circles, Repeats
 from lcode.sandbox import Sandbox, SandboxError, project_root
 from lcode.steer import NOTE_INTRO, Steering
 from lcode.tools import (
@@ -70,6 +71,7 @@ from lcode.tools import (
     tree,
     truncate,
 )
+from lcode.unreachable import NOTE_AT, Sites
 
 GPU_MEMORY_ERRORS = (
     "out of memory",
@@ -79,6 +81,27 @@ GPU_MEMORY_ERRORS = (
 )
 SAFE_NUM_BATCH = 512  # Ollama's default prompt batch
 MAX_STEPS_PER_TURN = 150
+MAX_STALLS = 2  # replies that go round in circles or say nothing, per request, before lcode stops it
+STALLED = {
+    "circles": "the reply went round in circles, so lcode stopped it",
+    "cut_off": "the reply filled the context before it said anything",
+    "": "the reply was empty",
+}
+
+
+def stall_note(trouble: str) -> str:
+    """What the model is told after a reply that went round in circles or ended without a word."""
+    first = {
+        "circles": "Your last reply went round in circles (the same thoughts over and over), so lcode stopped it.",
+        "cut_off": "Your last reply filled the rest of the context before you said anything.",
+        "": "Your last reply was empty.",
+    }[trouble]
+    return (
+        f"[lcode] {first} Don't deliberate at length now. Either make your next tool call, or, if you're stuck, "
+        "tell the user in a few lines what you did, what fails, and what they could do."
+    )
+
+
 EVENT_OUTPUT = 4000  # characters of a tool's output in an event
 # How a tool result starts when the call failed or wasn't allowed (an "error" in events and results).
 REFUSED = ("Error:", "A deny rule", "The user denied", "This needs the user's permission")
@@ -307,6 +330,9 @@ class Settings:
     repeat_limit: int = 3  # identical calls with identical results before the model is told (lcode.repeats)
     checks: str = "off"  # the project's checks after a change (lcode.checks): auto, off or a command
     review: str = "off"  # check a change against the request before the answer (lcode.review): auto or off
+    escalate_model: str | None = None  # a stronger model to ask when stuck (lcode.escalate): provider/model
+    escalate_url: str | None = None  # its server, when not the provider's usual one
+    escalate_price: str | None = None  # dollars per million tokens in/out, e.g. "3/15", for the cost estimate
 
 
 class Agent:
@@ -315,6 +341,9 @@ class Agent:
         self.ollama = ollama
         self.settings = settings
         self.cwd = cwd.resolve()
+        # The folder lcode works in: where it started, or where /cd or a resumed session took it. A shell
+        # command may move the working directory around its project (self.cwd), but not out of it.
+        self.workspace = self.cwd
         self.perms = Permissions(self.console, settings.permission_mode)
         self.tools = Toolbox(self)
         self.session_id = self.new_session_id()
@@ -369,10 +398,14 @@ class Agent:
         self._check: tuple[Path, checks.Check | None] | None = None
         self.check_results: list[dict] = []  # the checks of the last request: command, exit code, who ran them
         self.review_results: list[str] | None = None  # what the last request's review found (None: no review)
+        self.escalations: list[dict] = []  # the stronger model asked in the last request (lcode.escalate)
+        self.escalate_approved: bool | None = None  # decided in advance (lcode -p --escalate, the benchmark)
         self.sent_chars = 0  # characters of the conversation the model had already read
         self.counted_chars: int | None = None  # characters that ctx_used covers (None: all of them)
-        self.turn_status = ""  # how the last request ended: success, max_steps, loop
+        self.turn_status = ""  # how the last request ended: success, max_steps, loop, blocked
         self.repeats = Repeats(settings.repeat_limit)  # notices when the model repeats itself
+        self.sites = Sites(NOTE_AT if settings.repeat_limit else 0)  # notices a site this machine can't reach
+        self.reply_trouble = ""  # what went wrong with the last reply: "circles", "cut_off" or ""
         self.response = None  # the streaming response, so another thread can abort it
         self.ctx_used = 0
         self.last_speed = 0.0
@@ -642,7 +675,7 @@ class Agent:
         f = self.session_file()
         f.parent.mkdir(parents=True, exist_ok=True)
         data = {
-            "cwd": str(self.cwd),
+            "cwd": str(self.workspace),  # where `lcode -c` there finds it, wherever the shell moved
             "model": self.settings.model,
             "name": self.session_name,
             "title": self.session_title,
@@ -681,7 +714,7 @@ class Agent:
         saved_cwd = Path(info.cwd) if info.cwd else self.cwd
         if saved_cwd != self.cwd:
             if saved_cwd.is_dir():
-                self.cwd = saved_cwd.resolve()
+                self.cwd = self.workspace = saved_cwd.resolve()
                 note = f"Working directory is now {self.cwd}"
             else:
                 note = f"The session's directory {saved_cwd} no longer exists; staying in {self.cwd}"
@@ -701,7 +734,7 @@ class Agent:
         return note
 
     def load_latest(self) -> bool:
-        latest = sessions.list_sessions(self.cwd, limit=1)
+        latest = sessions.list_sessions(self.workspace, limit=1)
         if latest:
             self.load(latest[0])
         return bool(latest)
@@ -799,8 +832,11 @@ class Agent:
                 status = None
 
         start_spinner()
+        circles = Circles()
+        self.reply_trouble = ""
+        stream = self.chat(self.messages, self.tool_schemas(), self.settings.think)
         try:
-            for chunk in self.chat(self.messages, self.tool_schemas(), self.settings.think):
+            for chunk in stream:
                 if self.cancel is not None and self.cancel.is_set():
                     raise KeyboardInterrupt
                 msg = chunk.get("message", {})
@@ -816,6 +852,9 @@ class Agent:
                         stop_spinner()  # raw text is printed as it streams
                         self.console.print(Text(msg["thinking"], style="dim italic"), end="")
                         printed_thinking = True
+                    if self.settings.repeat_limit and circles.feed(msg["thinking"]):
+                        self.reply_trouble = "circles"
+                        break  # closing the stream below stops the model
                 if msg.get("content"):
                     if printed_thinking:
                         self.console.print("\n")
@@ -840,9 +879,12 @@ class Agent:
             self.messages.append({"role": "assistant", "content": content + "\n[interrupted by user]"})
             raise
         finally:
+            stream.close()
             stop_spinner()
             if watch is not None:
                 watch.stop()
+        if final.get("done_reason") == "length" and not self.reply_trouble:
+            self.reply_trouble = "cut_off"  # it filled the context (or hit the output limit) mid-reply
         if printed_thinking:
             self.console.print()
         md.flush()
@@ -912,6 +954,12 @@ class Agent:
             "is final, and gives you the failures to fix. Run them yourself while you work, too."
         )
 
+    def unrun_scripts(self, commands: list[str]) -> list[str]:
+        """Shell scripts the model wrote in this request and never ran (only where the checks would run)."""
+        if self.allowed_tools is not None or self.planning() or self.no_changes or self.settings.checks == "off":
+            return []
+        return checks.unrun_scripts(project_root_or_cwd(self.cwd), list(self.tools.before), commands)
+
     def project_check(self) -> checks.Check | None:
         """The project's check command, for the main agent outside plan mode and reviews (None otherwise)."""
         if self.allowed_tools is not None or self.planning() or self.no_changes or self.settings.checks == "off":
@@ -952,9 +1000,8 @@ class Agent:
             )
             return None
         if round_ >= checks.MAX_ROUNDS:
-            self.say(
-                f"Checks still fail ({check.command}, exit code {code}): the model will say what's left.", warning=True
-            )
+            then = "" if self.can_escalate() else ": the model will say what's left"
+            self.say(f"Checks still fail ({check.command}, exit code {code}){then}.", warning=True)
         else:
             self.say(
                 f"Checks fail ({check.command}, exit code {code}): the model gets the output to fix it.", warning=True
@@ -1101,14 +1148,21 @@ class Agent:
         self.messages.append({"role": "user", "content": self.expand_mentions(user_text) + note})
         self.turn_requests = [user_text.strip()]
         self.repeats.reset()
+        self.sites.reset()
         self.check_results = []
         self.review_results = None
+        self.escalations = []
+        escalated = False  # the stronger model is asked at most once per request
         self.tools.before = {}
         reviewed = False
         changed = verified = False  # files changed in this request; the checks passed since
         check_rounds = 0
         malformed = 0
         looping = ""  # the call the model kept repeating, when lcode stopped the request for it
+        blocked = None  # the site that couldn't be reached, when lcode stopped the request for it
+        stalls = 0  # replies that went round in circles or ended without a word
+        commands: list[str] = []  # shell commands run in this request
+        scripts_noted = False  # the model was told about scripts it wrote and never ran
         for step in range(self.max_steps):
             if self.cancel is not None and self.cancel.is_set():
                 raise KeyboardInterrupt
@@ -1158,14 +1212,60 @@ class Agent:
                     }
                 )
                 continue
+            if not calls and (self.reply_trouble == "circles" or not (reply.get("content") or "").strip()):
+                stalls += 1
+                self.messages.pop()  # nothing to keep: no answer, and circles would only fill the context
+                if stalls < MAX_STALLS:
+                    self.console.print(
+                        Text(f"  ⎿ {STALLED[self.reply_trouble]}: asking for a short answer", style="yellow")
+                    )
+                    self.messages.append({"role": "user", "content": stall_note(self.reply_trouble)})
+                    continue
+                why = "its replies went round in circles or ended without an answer, twice in this request"
+                if not escalated and self.can_escalate():
+                    escalated = True
+                    advice = escalate.run(self, why)
+                    if advice:
+                        self.messages.append({"role": "user", "content": advice})
+                        stalls = 0
+                        continue
+                self.turn_status = "loop"
+                self.console.print(
+                    Text(
+                        "Stopped: the model's replies went round in circles or ended without an answer, twice in "
+                        "this request. Try again with a smaller step, or tell it what to do differently.",
+                        style="yellow",
+                    )
+                )
+                return
             if not calls:
+                if self.reply_trouble == "cut_off":
+                    self.say(
+                        "The answer was cut off: the context window is full. /compact or a larger /context helps.",
+                        warning=True,
+                    )
                 if self.steering is not None and self.steering.waiting():
                     continue  # the user added a note while the model wrote its answer: it reads the note first
+                unrun = [] if scripts_noted else self.unrun_scripts(commands)
+                if unrun:
+                    scripts_noted = True
+                    self.console.print(Text(f"  ⎿ never ran {', '.join(unrun)}: asking the model to", style="yellow"))
+                    self.messages.append({"role": "user", "content": checks.unrun_note(unrun)})
+                    continue
                 check = self.project_check() if changed and not verified else None
                 if check is not None and check_rounds < checks.MAX_ROUNDS:
                     check_rounds += 1
                     feedback = self.run_check(check, check_rounds)
                     if feedback:
+                        if check_rounds >= checks.MAX_ROUNDS and not escalated and self.can_escalate():
+                            escalated = True
+                            why = f"the project's checks (`{check.command}`) failed {check_rounds} times in a row"
+                            advice = escalate.run(self, why, failure=feedback)
+                            if advice:
+                                self.messages.append({"role": "user", "content": advice})
+                                check_rounds -= 1  # the checks run once more after the advice
+                                changed = False
+                                continue
                         self.messages.append({"role": "user", "content": feedback})
                         changed = False  # run them again only if the model changes something more
                         continue
@@ -1231,6 +1331,21 @@ class Agent:
                     )
                     if verdict.stop:
                         looping = self.describe_call(name, args)
+                out_of_reach = self.sites.check(name, args, result)
+                if out_of_reach.note and not looping:
+                    result += out_of_reach.note
+                    what = "stopping the request" if out_of_reach.stop else "told the model"
+                    self.console.print(
+                        Text(
+                            f"  ⎿ {out_of_reach.calls} calls to {out_of_reach.site} failed "
+                            f"({out_of_reach.what}), none worked: {what}",
+                            style="yellow",
+                        )
+                    )
+                    if out_of_reach.stop:
+                        blocked = out_of_reach
+                if name == "bash":
+                    commands.append(str(args.get("command", "")))
                 if name in ("edit_file", "write_file", "apply_patch") and not result.startswith(REFUSED):
                     changed, verified = True, False
                 elif name == "bash" and changed and self.model_ran_checks(str(args.get("command", "")), result):
@@ -1248,7 +1363,7 @@ class Agent:
                         "output": result[:EVENT_OUTPUT] + ("…" if len(result) > EVENT_OUTPUT else ""),
                     }
                 )
-                if looping:
+                if looping or blocked:
                     for rest in calls[i + 1 :]:
                         skipped = {
                             "role": "tool",
@@ -1259,6 +1374,26 @@ class Agent:
                             skipped["tool_call_id"] = rest["id"]
                         self.messages.append(skipped)
                     break
+            if looping and not escalated and self.can_escalate():
+                escalated = True
+                advice = escalate.run(self, f"it kept making the same call with the same result: {looping}")
+                if advice:
+                    self.messages.append({"role": "user", "content": advice})
+                    self.repeats.reset()
+                    looping = ""
+                    continue
+            if blocked:
+                self.turn_status = "blocked"
+                self.console.print(
+                    Text(
+                        f"Stopped: every request to {blocked.site} failed ({blocked.calls} calls: {blocked.what}) and "
+                        "none worked, so this machine probably can't reach it: a firewall, a proxy, a regional block "
+                        "or no internet. Check the connection (another network or a VPN, a proxy setting), or tell "
+                        "the model another way to get what it needs.",
+                        style="yellow",
+                    )
+                )
+                return
             if looping:
                 self.turn_status = "loop"
                 self.console.print(
@@ -1276,6 +1411,11 @@ class Agent:
         self.turn_status = "success"
         self.print_stats()
 
+    def can_escalate(self) -> bool:
+        """Whether a stronger model may be asked here: one is set, and this isn't a subagent or plan mode."""
+        model = (self.settings.escalate_model or "").strip().lower()
+        return bool(model) and model != "off" and self.allowed_tools is None and not self.planning()
+
     def steer(self) -> None:
         """Between two steps: pause if the user pressed Esc, then hand the model the notes typed meanwhile."""
         steering = self.steering

lcode/api.py

@@ -78,6 +78,7 @@ class Result:
     usage: dict = field(default_factory=dict)  # requests, prompt_tokens, output_tokens
     checks: list[dict] = field(default_factory=list)  # {"command", "exit_code", "by": "lcode" | "model"}
     review: list[str] | None = None  # problems the review sent back ([] when it found none; None: no review)
+    escalations: list[dict] = field(default_factory=list)  # a stronger model asked: model, why, tokens, seconds
     seconds: float = 0.0
     error: str = ""
 
@@ -200,6 +201,9 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         repeat_limit=cfg["repeat_limit"],
         checks=cfg["checks"],
         review=cfg["review"],
+        escalate_model=cfg["escalate_model"],
+        escalate_url=cfg["escalate_url"],
+        escalate_price=cfg["escalate_price"],
         compact_at=cfg["compact_at"],
     )
     agent = Agent(ollama, settings, cwd, console=console)
@@ -281,7 +285,7 @@ def run_request(agent: Agent, prompt: str) -> Result:
 
     try:
         agent.run_turn(prompt)
-        status = agent.turn_status if agent.turn_status in ("max_steps", "loop") else "success"
+        status = agent.turn_status if agent.turn_status in ("max_steps", "loop", "blocked") else "success"
     except KeyboardInterrupt:
         status, error = "interrupted", "interrupted before the request was done"
     except ModelError as e:
@@ -309,6 +313,7 @@ def run_request(agent: Agent, prompt: str) -> Result:
         usage=usage,
         checks=list(agent.check_results),
         review=agent.review_results,
+        escalations=list(agent.escalations),
         seconds=round(time.monotonic() - started, 2),
         error=error,
     )

lcode/backends.py

@@ -265,11 +265,16 @@ class OpenAICompatible:
             return self.chat({k: v for k, v in payload.items() if k not in ("format", "tools")}, timeout)
         if r.status_code != 200:
             raise self._failed(r.status_code, r.text)
-        choice = (r.json().get("choices") or [{}])[0].get("message") or {}
+        data = r.json()
+        choice = (data.get("choices") or [{}])[0].get("message") or {}
         message: dict = {"role": "assistant", "content": strip_thinking(choice.get("content") or "")}
         if choice.get("tool_calls"):
             message["tool_calls"] = [self._ollama_call(c) for c in choice["tool_calls"]]
-        return {"message": message}
+        reply: dict = {"message": message}
+        usage = data.get("usage") or {}
+        if usage.get("prompt_tokens") is not None:  # as Ollama counts them
+            reply["prompt_eval_count"], reply["eval_count"] = usage["prompt_tokens"], usage.get("completion_tokens")
+        return reply
 
     @staticmethod
     def _ollama_call(call: dict) -> dict:
@@ -297,6 +302,7 @@ class OpenAICompatible:
         calls: dict[int, dict] = {}
         usage: dict = {}
         timings: dict = {}  # llama-server measures prompt and generation time itself
+        finished = ""  # why the reply ended, as Ollama's done_reason: "length" when it was cut off
         splitter = ThinkSplitter()
         first_token = None
         with r:
@@ -318,6 +324,7 @@ class OpenAICompatible:
                 usage = chunk.get("usage") or usage
                 timings = chunk.get("timings") or timings
                 for choice in chunk.get("choices") or []:
+                    finished = choice.get("finish_reason") or finished
                     delta = choice.get("delta") or {}
                     thinking = delta.get("reasoning_content") or delta.get("reasoning")
                     if thinking:
@@ -351,6 +358,7 @@ class OpenAICompatible:
             "prompt_eval_duration": first_token - started,
             "eval_count": int(usage.get("completion_tokens") or 0),
             "eval_duration": max(1, ended - first_token),
+            "done_reason": "length" if finished == "length" else "stop",
         }
         if timings.get("prompt_ms") is not None and timings.get("predicted_ms"):
             # The whole prompt counts (it's what fills the context), cached tokens included.

lcode/bench.py

@@ -29,7 +29,7 @@ from rich.markup import escape
 from rich.table import Table
 from rich.text import Text
 
-from lcode import __version__
+from lcode import __version__, escalate
 from lcode.agent import Agent, Settings
 from lcode.config import format_tokens
 from lcode.hardware import Hardware
@@ -790,6 +790,8 @@ class TaskResult:
     tool_errors: int = 0  # failed tool calls, including malformed ones
     error: str | None = None  # why the run stopped early: a timeout or an Ollama error
     errors_by_tool: dict[str, int] = field(default_factory=dict)  # which tools failed, "malformed" for unreadable calls
+    first_passed: bool | None = None  # with --retry: whether the first try passed (None: no retry was needed)
+    escalations: int = 0  # times the stronger model was asked (--escalate)
 
 
 @dataclass
@@ -887,8 +889,13 @@ def run_task(
     keep: bool,
     usage: dict,
     agent: Agent | None = None,
+    retry: bool = False,
 ) -> TaskResult:
-    """Run one task in a new folder: in a new conversation, or continuing `agent`'s (--session)."""
+    """Run one task in a new folder: in a new conversation, or continuing `agent`'s (--session).
+
+    With `retry`, a failed task gets one more try, as a user would ask: "That didn't fix it. Look again." With a
+    stronger model set (--escalate), its advice goes along, as with /escalate.
+    """
     folder = Path(tempfile.mkdtemp(prefix=f"lcode-bench-{task.id}-"))
     try:
         for rel, content in task.files.items():
@@ -897,7 +904,7 @@ def run_task(
         if agent is None:
             agent = Agent(ollama, settings, folder, console=log)
         else:  # the same conversation moves on to this task's folder, as with /cd
-            agent.cwd = folder.resolve()
+            agent.cwd = agent.workspace = folder.resolve()
             agent.messages[0]["content"] = agent.system_prompt()
         if settings.embed_model != "off":  # --code-search: index the task's folder first, outside the timer
             from lcode import codesearch
@@ -906,25 +913,28 @@ def run_task(
             if model:
                 codesearch.Index(folder, model).update(ollama)  # on the CPU: lcode's model stays loaded
             agent._code_index = None
+        agent.escalate_approved = True if settings.escalate_model else None  # the --escalate flag is the OK
         before = dict(agent.usage)
         first = len(agent.messages)
-        error = None
         started = time.monotonic()
-        try:
-            with time_limit(timeout):
-                agent.run_turn(task.prompt)
-        except TaskTimeout:
-            error = f"timed out after {timeout:.0f}s"
-        except OllamaError as e:
-            error = str(e).splitlines()[0][:200]
+        escalations = 0
+        error = attempt(agent, task.prompt, timeout)
+        escalations += len(agent.escalations)
+        check = checked(task, folder, agent)
+        first_passed = None
+        if retry and not (check.passed and error is None):
+            first_passed = False
+            text = RETRY
+            if error is None and agent.can_escalate():
+                advice = escalate.run(agent, "the user says the fix didn't work")
+                escalations += 1 if advice else 0
+                text = f"{RETRY}\n\n{advice}" if advice else RETRY
+            error = attempt(agent, text, timeout)
+            escalations += len(agent.escalations)
+            check = checked(task, folder, agent)
         seconds = time.monotonic() - started
         for key, value in agent.usage.items():
             usage[key] = usage.get(key, 0) + value - before.get(key, 0)
-        answer = next((m.get("content", "") for m in reversed(agent.messages) if m.get("role") == "assistant"), "")
-        try:
-            check = task.check(folder, answer)
-        except Exception as e:  # a check must never crash the benchmark
-            check = Check(False, f"check failed: {type(e).__name__}: {e}")
     finally:  # also when Ctrl+C stops the task
         from lcode.codesearch import index_dir
 
@@ -942,9 +952,34 @@ def run_task(
         tool_errors=count_tool_errors(agent.messages[first:] if len(agent.messages) > first else agent.messages),
         errors_by_tool=errors_by_tool(agent.messages[first:] if len(agent.messages) > first else agent.messages),
         error=error,
+        first_passed=first_passed,
+        escalations=escalations,
     )
 
 
+RETRY = "That didn't fix it: it still doesn't work right. Look again."
+
+
+def attempt(agent: Agent, text: str, timeout: float) -> str | None:
+    """One request of a task; why it stopped early, if it did."""
+    try:
+        with time_limit(timeout):
+            agent.run_turn(text)
+    except TaskTimeout:
+        return f"timed out after {timeout:.0f}s"
+    except OllamaError as e:
+        return str(e).splitlines()[0][:200]
+    return None
+
+
+def checked(task: Task, folder: Path, agent: Agent) -> Check:
+    answer = next((m.get("content", "") for m in reversed(agent.messages) if m.get("role") == "assistant"), "")
+    try:
+        return task.check(folder, answer)
+    except Exception as e:  # a check must never crash the benchmark
+        return Check(False, f"check failed: {type(e).__name__}: {e}")
+
+
 def prompt_speed(ollama: Ollama, settings: Settings, options: dict) -> float | None:
     """Prompt tokens per second for prompts the model hasn't seen: the faster of two readings.
 
@@ -998,6 +1033,7 @@ def run_model(
     keep: bool = False,
     verbose: bool = False,
     session: bool = False,
+    retry: bool = False,
 ) -> ModelRun:
     run = ModelRun(name, settings.model, settings.context, settings.num_batch, settings.think, session=session)
     shared: Agent | None = None  # with --session, one conversation for all tasks
@@ -1038,10 +1074,10 @@ def run_model(
         try:
             if verbose:
                 console.rule(f"{task.id}: {task.title}")
-                result = run_task(ollama, settings, task, timeout, log, keep, run.usage, shared)
+                result = run_task(ollama, settings, task, timeout, log, keep, run.usage, shared, retry)
             else:
                 with console.status(Elapsed(f"  {task.id:<13} {task.title}")):
-                    result = run_task(ollama, settings, task, timeout, log, keep, run.usage, shared)
+                    result = run_task(ollama, settings, task, timeout, log, keep, run.usage, shared, retry)
         except KeyboardInterrupt:
             console.print("  [yellow]Stopped.[/]")
             run.interrupted = True

lcode/checks.py

@@ -158,3 +158,74 @@ def missing(check: Check, result: str) -> bool:
         return True
     head = result.splitlines()[:5]  # a missing program says so first; test failures look different
     return code not in (0, None) and any(MISSING.search(line) for line in head)
+
+
+# ----------------------------------------------------------------------------- scripts written, never run
+
+SCRIPT_SUFFIXES = (".sh", ".bash", ".zsh")
+SHELL_SHEBANG = re.compile(r"^#!\S*?(?:/|env\s+)(?:ba|z|da|k)?sh\b")
+RUNNERS = frozenset({"bash", "sh", "zsh", "dash", "ksh", "source", ".", "exec"})
+PREFIXES = frozenset({"sudo", "time", "nohup", "env", "command", "nice"})
+SEGMENTS = re.compile(r"&&|\|\||[;|\n&()]")
+
+
+def unrun_scripts(root: Path, changed: list[str], commands: list[str]) -> list[str]:
+    """Shell scripts written in this request that no command in it ran.
+
+    Small models write a build or install script and call it done without running it once; the first thing
+    the user then sees is its first error. Only shell scripts count (a .sh file, or a shell shebang): a Python
+    file with a shebang is as likely an app or a server that never ends.
+    """
+    unrun = []
+    for rel in changed:
+        path = root / rel
+        if not is_shell_script(path):
+            continue
+        if not any(runs(command, path.name) for command in commands):
+            unrun.append(rel)
+    return unrun
+
+
+def is_shell_script(path: Path) -> bool:
+    if not path.is_file():
+        return False
+    if path.suffix in SCRIPT_SUFFIXES:
+        return True
+    if path.suffix:
+        return False
+    try:
+        with path.open("rb") as f:
+            first = f.readline(200).decode("utf-8", "replace")
+    except OSError:
+        return False
+    return bool(SHELL_SHEBANG.match(first))
+
+
+def runs(command: str, name: str) -> bool:
+    """Whether a shell command runs the script called `name` (not just chmods, cats or commits it)."""
+    for segment in SEGMENTS.split(command):
+        words = segment.split()
+        while words and (("=" in words[0] and not words[0].startswith("=")) or words[0] in PREFIXES):
+            words.pop(0)
+        if words and words[0] == "timeout":
+            words = words[2:] if len(words) > 2 else []
+        if not words:
+            continue
+        program = words[0].strip("'\"")
+        if program in RUNNERS:
+            rest = [w.strip("'\"") for w in words[1:] if not w.startswith("-")]
+            program = rest[0] if rest else ""
+        if Path(program).name == name:
+            return True
+    return False
+
+
+def unrun_note(scripts: list[str]) -> str:
+    names = ", ".join(scripts)
+    it = "it" if len(scripts) == 1 else "them"
+    return (
+        f"[lcode] You wrote {names} in this request but never ran {it}. Run {it} now and fix what fails, so you know "
+        f"{it} works before you say so. If running {it} would change things outside the project (install packages, "
+        f"deploy, delete data) or needs something you don't have, don't: tell the user plainly that {it} is untested "
+        "and why."
+    )