nock-cli 0.1.0__tar.gz → 0.3.0__tar.gz

nock_cli-0.3.0/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: nock-cli
+Version: 0.3.0
+Summary: Open models that live on your machine: code, video and a coding agent, offline.
+Author: NockAI
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://nockai.dev
+Project-URL: Model, https://huggingface.co/Nock-AI/nock-video-4b-GGUF
+Keywords: local,offline,llm,video,llama.cpp,gguf
+Classifier: Environment :: Console
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: links
+Requires-Dist: yt-dlp; extra == "links"
+Dynamic: license-file
+
+# Nock CLI
+
+Open models that live on your machine. One tool for the NockAI family: code, video, and a coding agent, offline.
+
+```bash
+nock add coder video
+nock code "regex for an EVM address"
+nock video find meeting.mp4 "when do they talk about the budget"
+nock fix ./my-project "the total is off by one"     # experimental, big GPU
+```
+
+Everything runs on your computer. The models run in a local llama.cpp server on `127.0.0.1`. Nothing is uploaded.
+
+## Install
+
+You need Python 3.9 or newer.
+
+```bash
+pipx install nock-cli
+nock add coder        # or: video, agent
+nock doctor
+```
+
+`nock add` downloads, once:
+- the engine: an official [llama.cpp](https://github.com/ggml-org/llama.cpp) build (about 35 MB; Vulkan on Windows
+  and Linux, Metal on Apple Silicon). Already have `llama-server`? Nock uses it.
+- the skill's model from Hugging Face.
+
+| Skill | Model | Download | Needs |
+|---|---|---|---|
+| `coder` | [Nock Coder 1.5B](https://huggingface.co/Nock-AI/nock-coder-1.5b-GGUF) | 1 GB | any laptop |
+| `video` | [Nock Video 4B](https://huggingface.co/Nock-AI/nock-video-4b-GGUF) (preview) | 3.4 GB | a GPU with 6 GB for 64 frames; [ffmpeg](https://ffmpeg.org/download.html) |
+| `agent` | [Nock Agent 31B](https://huggingface.co/Nock-AI/nock-agent-31b-GGUF) (experimental) | 18.7 GB | a GPU with about 20 GB (a Mac with 32 GB or more may work; not tested) |
+
+`nock list` shows what is installed, `nock remove <skill>` deletes a skill's files. Files go to `~/.nock`
+(set `NOCK_HOME` to use another folder).
+
+## Nock Coder: `nock code`
+
+```bash
+nock code "write a Solidity ERC-20 with a cap"
+cat error.log | nock code "why does this fail?"
+nock code                                  # a chat; type exit to quit
+```
+
+Code first, one short line of explanation. The same model and prompt as `ollama run nockai/nock-coder`. It is a
+1.5B model, so review code before you run it. On HumanEval it passes 118 of 164.
+
+## Nock Video: `nock video`
+
+```bash
+nock video summarize meeting.mp4
+nock video ask clip.mp4 "what error message shows on screen?"
+nock video find clip.mp4 "when the cake comes out"
+```
+
+Files or links. Links are downloaded to your own machine with [yt-dlp](https://github.com/yt-dlp/yt-dlp), which
+you install yourself (`pipx inject nock-cli yt-dlp`). Only use videos you have the right to use.
+
+Nock Video 4B is a **preview**. On our test of 20 videos, through llama.cpp at 64 frames, it found the moment in
+43 of 56 questions, answered 59 of 60 questions about what is on screen, and gave 6 of 7 good summaries. Full
+results, including the misses, are on the [model card](https://huggingface.co/Nock-AI/nock-video-4b-GGUF).
+
+- It reads frames only, not sound.
+- A long video is read as at most 64 frames, so short events in long videos can be missed.
+- 64 frames used about 5.5 GB of GPU memory in our test. On GPUs under 6 GB, Nock uses 32 frames (the first
+  preview dropped from 42 to 35 of 56 moments at 32 frames; the current model was not measured at 32).
+  `--frames` overrides it.
+
+## Nock Agent: `nock fix` (experimental)
+
+```bash
+nock fix ./my-project "the total is off by one"
+```
+
+Nock Agent reads the code, makes the smallest edit and runs the tests. On our agent test it solved 145 of 150 runs
+and edited a test file 0 times. It works on your own files, so **every edit is shown as a diff and every command
+before it runs, and each one needs your yes**. `--yes` skips the questions; use it only in a copy or a git branch.
+It refuses to start on GPUs under about 20 GB (`--force` to try anyway, very slowly).
+
+## Use it from your apps: `nock serve`
+
+```bash
+nock serve
+```
+
+One local, OpenAI-compatible address for every skill you have installed. In your editor or tool, set the base URL to
+`http://127.0.0.1:8080/v1`, any API key, and the model to `nock-coder`, `nock-video` or `nock-agent`.
+
+```bash
+curl http://127.0.0.1:8080/v1/chat/completions -H "Content-Type: application/json"   -d '{"model": "nock-coder", "messages": [{"role": "user", "content": "regex for an EVM address"}]}'
+```
+
+The model starts on first use, and one model is in memory at a time, so asking for another swaps them (it can take
+a while). Streaming works. It listens on this machine only, refuses requests from websites, and logs no questions or
+answers. `--port` changes the port.
+
+## Speed and GPUs
+
+`nock doctor` shows which device the engine uses. If it says **software device** or **no GPU device**, the
+engine runs on the CPU and answers take many minutes. This happens inside most containers and VMs. On a machine
+with an NVIDIA GPU, `nock setup --backend cuda` installs the CUDA build instead (a bigger download: about 630 MB on Windows, 740 MB on Linux).
+
+| Option | Meaning |
+|---|---|
+| `--backend vulkan\|cuda\|cpu\|metal` | which llama.cpp build `nock add` / `nock setup` installs |
+| `NOCK_LLAMA_SERVER=/path/llama-server` | use your own llama.cpp build |
+| `NOCK_HOME=/path` | where models and the engine are stored |
+
+Server logs are in `~/.nock/logs/` if something goes wrong.
+
+## License
+
+Apache-2.0. Each model has its own license on its model card (all Apache-2.0).

nock_cli-0.3.0/README.md

@@ -0,0 +1,114 @@
+# Nock CLI
+
+Open models that live on your machine. One tool for the NockAI family: code, video, and a coding agent, offline.
+
+```bash
+nock add coder video
+nock code "regex for an EVM address"
+nock video find meeting.mp4 "when do they talk about the budget"
+nock fix ./my-project "the total is off by one"     # experimental, big GPU
+```
+
+Everything runs on your computer. The models run in a local llama.cpp server on `127.0.0.1`. Nothing is uploaded.
+
+## Install
+
+You need Python 3.9 or newer.
+
+```bash
+pipx install nock-cli
+nock add coder        # or: video, agent
+nock doctor
+```
+
+`nock add` downloads, once:
+- the engine: an official [llama.cpp](https://github.com/ggml-org/llama.cpp) build (about 35 MB; Vulkan on Windows
+  and Linux, Metal on Apple Silicon). Already have `llama-server`? Nock uses it.
+- the skill's model from Hugging Face.
+
+| Skill | Model | Download | Needs |
+|---|---|---|---|
+| `coder` | [Nock Coder 1.5B](https://huggingface.co/Nock-AI/nock-coder-1.5b-GGUF) | 1 GB | any laptop |
+| `video` | [Nock Video 4B](https://huggingface.co/Nock-AI/nock-video-4b-GGUF) (preview) | 3.4 GB | a GPU with 6 GB for 64 frames; [ffmpeg](https://ffmpeg.org/download.html) |
+| `agent` | [Nock Agent 31B](https://huggingface.co/Nock-AI/nock-agent-31b-GGUF) (experimental) | 18.7 GB | a GPU with about 20 GB (a Mac with 32 GB or more may work; not tested) |
+
+`nock list` shows what is installed, `nock remove <skill>` deletes a skill's files. Files go to `~/.nock`
+(set `NOCK_HOME` to use another folder).
+
+## Nock Coder: `nock code`
+
+```bash
+nock code "write a Solidity ERC-20 with a cap"
+cat error.log | nock code "why does this fail?"
+nock code                                  # a chat; type exit to quit
+```
+
+Code first, one short line of explanation. The same model and prompt as `ollama run nockai/nock-coder`. It is a
+1.5B model, so review code before you run it. On HumanEval it passes 118 of 164.
+
+## Nock Video: `nock video`
+
+```bash
+nock video summarize meeting.mp4
+nock video ask clip.mp4 "what error message shows on screen?"
+nock video find clip.mp4 "when the cake comes out"
+```
+
+Files or links. Links are downloaded to your own machine with [yt-dlp](https://github.com/yt-dlp/yt-dlp), which
+you install yourself (`pipx inject nock-cli yt-dlp`). Only use videos you have the right to use.
+
+Nock Video 4B is a **preview**. On our test of 20 videos, through llama.cpp at 64 frames, it found the moment in
+43 of 56 questions, answered 59 of 60 questions about what is on screen, and gave 6 of 7 good summaries. Full
+results, including the misses, are on the [model card](https://huggingface.co/Nock-AI/nock-video-4b-GGUF).
+
+- It reads frames only, not sound.
+- A long video is read as at most 64 frames, so short events in long videos can be missed.
+- 64 frames used about 5.5 GB of GPU memory in our test. On GPUs under 6 GB, Nock uses 32 frames (the first
+  preview dropped from 42 to 35 of 56 moments at 32 frames; the current model was not measured at 32).
+  `--frames` overrides it.
+
+## Nock Agent: `nock fix` (experimental)
+
+```bash
+nock fix ./my-project "the total is off by one"
+```
+
+Nock Agent reads the code, makes the smallest edit and runs the tests. On our agent test it solved 145 of 150 runs
+and edited a test file 0 times. It works on your own files, so **every edit is shown as a diff and every command
+before it runs, and each one needs your yes**. `--yes` skips the questions; use it only in a copy or a git branch.
+It refuses to start on GPUs under about 20 GB (`--force` to try anyway, very slowly).
+
+## Use it from your apps: `nock serve`
+
+```bash
+nock serve
+```
+
+One local, OpenAI-compatible address for every skill you have installed. In your editor or tool, set the base URL to
+`http://127.0.0.1:8080/v1`, any API key, and the model to `nock-coder`, `nock-video` or `nock-agent`.
+
+```bash
+curl http://127.0.0.1:8080/v1/chat/completions -H "Content-Type: application/json"   -d '{"model": "nock-coder", "messages": [{"role": "user", "content": "regex for an EVM address"}]}'
+```
+
+The model starts on first use, and one model is in memory at a time, so asking for another swaps them (it can take
+a while). Streaming works. It listens on this machine only, refuses requests from websites, and logs no questions or
+answers. `--port` changes the port.
+
+## Speed and GPUs
+
+`nock doctor` shows which device the engine uses. If it says **software device** or **no GPU device**, the
+engine runs on the CPU and answers take many minutes. This happens inside most containers and VMs. On a machine
+with an NVIDIA GPU, `nock setup --backend cuda` installs the CUDA build instead (a bigger download: about 630 MB on Windows, 740 MB on Linux).
+
+| Option | Meaning |
+|---|---|
+| `--backend vulkan\|cuda\|cpu\|metal` | which llama.cpp build `nock add` / `nock setup` installs |
+| `NOCK_LLAMA_SERVER=/path/llama-server` | use your own llama.cpp build |
+| `NOCK_HOME=/path` | where models and the engine are stored |
+
+Server logs are in `~/.nock/logs/` if something goes wrong.
+
+## License
+
+Apache-2.0. Each model has its own license on its model card (all Apache-2.0).

{nock_cli-0.1.0 → nock_cli-0.3.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nock-cli"
-version = "0.1.0"
-description = "Open models that live on your machine. Ask questions about your videos, offline."
+version = "0.3.0"
+description = "Open models that live on your machine: code, video and a coding agent, offline."
 readme = "README.md"
 requires-python = ">=3.9"
 license = "Apache-2.0"

{nock_cli-0.1.0 → nock_cli-0.3.0}/src/nock_cli/__init__.py

@@ -1,3 +1,3 @@
 """Nock CLI: open models that live on your machine."""
 
-__version__ = "0.1.0"
+__version__ = "0.3.0"

nock_cli-0.3.0/src/nock_cli/agent.py

@@ -0,0 +1,193 @@
+"""Nock Agent (experimental): fixes an issue in a project folder on your machine.
+
+The loop and the five tools are the ones Nock Agent was tested with (runpod/harness.py). Because it works on your
+own files, every edit is shown as a diff and every command is shown before it runs, and each needs a yes
+(`--yes` skips the questions). Reading and searching need no approval. Paths outside the project are refused.
+"""
+
+import difflib
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+from nock_cli.chat import complete
+
+MAX_STEPS = 30
+COMMAND_TIMEOUT = 120
+MAX_TOKENS = 2048
+SEARCH_SUFFIXES = (".py", ".js", ".ts", ".tsx", ".jsx", ".go", ".rs", ".java", ".kt", ".rb", ".php", ".c", ".h", ".cpp",
+                   ".cs", ".sol", ".sh", ".txt", ".md", ".cfg", ".toml", ".json", ".yaml", ".yml", ".html", ".css")
+SKIPPED_FOLDERS = {".git", "node_modules", ".venv", "venv", "__pycache__", "dist", "build", ".next", "target"}
+
+AGENT_PROMPT = (
+  "You are Nock Agent, a coding agent working in a project folder. Use the tools to read the code, make the "
+  "smallest correct edit, and run the tests. Never edit test files. When the tests pass, reply with a one line "
+  "summary and stop calling tools."
+)
+
+TOOLS = [
+  {"type": "function", "function": {
+    "name": "read_file", "description": "Read a text file from the project. Optionally only a line range.",
+    "parameters": {"type": "object", "required": ["path"], "properties": {
+      "path": {"type": "string", "description": "File path relative to the project root"},
+      "start_line": {"type": "integer", "description": "First line to read (1 based)"},
+      "end_line": {"type": "integer", "description": "Last line to read"},
+    }}}},
+  {"type": "function", "function": {
+    "name": "edit_file", "description": "Replace one exact piece of text in a file with new text.",
+    "parameters": {"type": "object", "required": ["path", "old_text", "new_text"], "properties": {
+      "path": {"type": "string"},
+      "old_text": {"type": "string", "description": "Exact text to find, copied from the file"},
+      "new_text": {"type": "string", "description": "Text to put in its place"},
+    }}}},
+  {"type": "function", "function": {
+    "name": "write_file", "description": "Create a file or overwrite it with new content.",
+    "parameters": {"type": "object", "required": ["path", "content"], "properties": {
+      "path": {"type": "string"}, "content": {"type": "string"},
+    }}}},
+  {"type": "function", "function": {
+    "name": "search_code", "description": "Search all project files for a piece of text. Returns file:line matches.",
+    "parameters": {"type": "object", "required": ["query"], "properties": {"query": {"type": "string"}}}}},
+  {"type": "function", "function": {
+    "name": "run_command", "description": "Run a shell command in the project folder and return its output.",
+    "parameters": {"type": "object", "required": ["command"], "properties": {"command": {"type": "string"}}}}},
+]
+
+
+class Approver:
+  """Asks before each change. `always` (from --yes) approves everything without asking."""
+
+  def __init__(self, always=False, ask=input):
+    self.always = always
+    self.ask = ask
+
+  def __call__(self, title, detail):
+    print(f"\n{title}\n{detail}", file=sys.stderr)
+    if self.always:
+      return True
+    try:
+      return self.ask("Allow? [y/N] ").strip().lower() in ("y", "yes")
+    except EOFError:
+      return False
+
+
+def inside(root, path):
+  target = (root / path).resolve()
+  if target != root and root not in target.parents:
+    raise ValueError("path outside the project")
+  return target
+
+
+def diff_text(path, before, after):
+  lines = difflib.unified_diff(before.splitlines(), after.splitlines(), f"a/{path}", f"b/{path}", lineterm="")
+  return "\n".join(lines) or "(no change)"
+
+
+def project_files(root):
+  for path in sorted(root.rglob("*")):
+    if path.is_file() and path.suffix in SEARCH_SUFFIXES and not SKIPPED_FOLDERS.intersection(path.relative_to(root).parts):
+      yield path
+
+
+def run_tool(root, name, arguments, approve):
+  """Runs one tool call. Errors and refusals go back to the model as text."""
+  try:
+    if name == "read_file":
+      text = inside(root, arguments["path"]).read_text(encoding="utf-8")
+      if not arguments.get("start_line") and not arguments.get("end_line"):
+        return text or "(empty file)"
+      lines = text.splitlines()
+      start = max(1, int(arguments.get("start_line") or 1))
+      end = min(len(lines), int(arguments.get("end_line") or len(lines)))
+      return f"Lines {start} to {end} of {len(lines)}:\n" + "\n".join(lines[start - 1:end])
+    if name == "search_code":
+      matches = []
+      for file in project_files(root):
+        try:
+          lines = file.read_text(encoding="utf-8").splitlines()
+        except UnicodeDecodeError:
+          continue
+        for number, line in enumerate(lines, 1):
+          if arguments["query"] in line:
+            matches.append(f"{file.relative_to(root).as_posix()}:{number}: {line.strip()}")
+      return "\n".join(matches[:30]) or "No matches."
+    if name == "edit_file":
+      target = inside(root, arguments["path"])
+      text = target.read_text(encoding="utf-8")
+      if arguments["old_text"] not in text:
+        return "Error: old_text not found in the file. Read the file again and copy the text exactly."
+      updated = text.replace(arguments["old_text"], arguments["new_text"], 1)
+      if not approve(f"Edit {arguments['path']}:", diff_text(arguments["path"], text, updated)):
+        return "The user declined this edit."
+      target.write_text(updated, encoding="utf-8")
+      return f"Edited {arguments['path']}"
+    if name == "write_file":
+      target = inside(root, arguments["path"])
+      before = target.read_text(encoding="utf-8") if target.exists() else ""
+      title = f"{'Overwrite' if target.exists() else 'Create'} {arguments['path']}:"
+      if not approve(title, diff_text(arguments["path"], before, arguments["content"])):
+        return "The user declined writing this file."
+      target.parent.mkdir(parents=True, exist_ok=True)
+      target.write_text(arguments["content"], encoding="utf-8")
+      return f"Wrote {arguments['path']}"
+    if name == "run_command":
+      if not approve("Run in the project folder:", f"  $ {arguments['command']}"):
+        return "The user declined running this command."
+      completed = subprocess.run(arguments["command"], shell=True, cwd=root, capture_output=True, text=True,
+                                 timeout=COMMAND_TIMEOUT)
+      return ((completed.stdout + completed.stderr)[-3000:]).strip() or f"(no output, exit code {completed.returncode})"
+    return f"Error: unknown tool {name}"
+  except subprocess.TimeoutExpired:
+    return f"Error: the command took longer than {COMMAND_TIMEOUT} seconds and was stopped."
+  except Exception as error:  # reported to the model, like an editor would
+    return f"Error: {type(error).__name__}: {error}"
+
+
+def parse_arguments(raw):
+  if isinstance(raw, dict):
+    return raw
+  try:
+    value = json.loads(raw or "{}")
+    return value if isinstance(value, dict) else {}
+  except json.JSONDecodeError:
+    return {}
+
+
+def describe(name, arguments):
+  if name == "read_file":
+    return f"reads {arguments.get('path')}"
+  if name == "search_code":
+    return f"searches for {arguments.get('query')!r}"
+  return name.replace("_", " ")
+
+
+def run(project, task, approve, start_server, max_steps=MAX_STEPS):
+  root = Path(project).resolve()
+  if not root.is_dir():
+    raise ValueError(f"Not a folder: {project}")
+  messages = [
+    {"role": "system", "content": AGENT_PROMPT},
+    {"role": "user", "content": f"{task} Find and run the project's tests to check your fix."},
+  ]
+  with start_server() as server:
+    for step in range(max_steps):
+      message = complete(server.url, messages, MAX_TOKENS, tools=TOOLS)
+      calls = message.get("tool_calls") or []
+      record = {"role": "assistant", "content": message.get("content") or ""}
+      if calls:
+        record["tool_calls"] = [
+          {"id": call.get("id") or f"call_{step}_{index}", "type": "function",
+           "function": {"name": call["function"]["name"], "arguments": json.dumps(parse_arguments(call["function"].get("arguments")))}}
+          for index, call in enumerate(calls)
+        ]
+      messages.append(record)
+      if not calls:
+        return record["content"].strip() or "Done."
+      for call in record["tool_calls"]:
+        name, arguments = call["function"]["name"], parse_arguments(call["function"]["arguments"])
+        if name in ("read_file", "search_code"):
+          print(f"  Nock Agent {describe(name, arguments)}", file=sys.stderr)
+        output = run_tool(root, name, arguments, approve)
+        messages.append({"role": "tool", "tool_call_id": call["id"], "name": name, "content": output})
+  return f"Stopped after {max_steps} steps without finishing. Check the changes it made."

nock_cli-0.3.0/src/nock_cli/chat.py

@@ -0,0 +1,19 @@
+"""One call to the local llama-server's OpenAI-style chat endpoint (127.0.0.1 only)."""
+
+import json
+import urllib.request
+
+REQUEST_TIMEOUT = 1800  # CPU-only machines can take many minutes
+
+
+def complete(server_url, messages, max_tokens, temperature=0.0, tools=None, extra=None):
+  """Returns the assistant message (a dict with `content` and maybe `tool_calls`)."""
+  body = {"messages": messages, "temperature": temperature, "max_tokens": max_tokens}
+  if tools:
+    body["tools"] = tools
+    body["tool_choice"] = "auto"
+  body.update(extra or {})
+  request = urllib.request.Request(f"{server_url}/v1/chat/completions", data=json.dumps(body).encode(),
+                                   headers={"Content-Type": "application/json"})
+  with urllib.request.urlopen(request, timeout=REQUEST_TIMEOUT) as response:
+    return json.load(response)["choices"][0]["message"]

nock_cli-0.3.0/src/nock_cli/code.py

@@ -0,0 +1,62 @@
+"""Nock Coder in the terminal: one question, piped input, or a chat until you quit.
+
+Same system prompt and temperature as the Ollama model (ollama/Modelfile), so answers match `ollama run nockai/nock-coder`.
+"""
+
+import sys
+
+from nock_cli.chat import complete
+
+SYSTEM_PROMPT = ("You are Nock Coder, an open coding model from NockAI. Reply with code first. Keep any explanation to "
+                 "one short sentence. For Solidity, use pragma solidity ^0.8.0 unless the user asks for another version.")
+TEMPERATURE = 0.2
+MAX_TOKENS = 1024
+MAX_PIPED_CHARS = 20000  # about 5K tokens: leaves room in the 8K context for the question and the answer
+EXIT_WORDS = ("exit", "quit", ":q")
+
+
+def first_message(prompt, piped):
+  """The question with piped text (a file or an error log). The text goes first and the question last: with the
+  question first, Nock Coder repeated the code instead of answering (checked 2026-10-26 on a ZeroDivisionError log)."""
+  if piped and len(piped) > MAX_PIPED_CHARS:
+    print(f"Input is long: only the last {MAX_PIPED_CHARS:,} characters are sent.", file=sys.stderr)
+    piped = piped[-MAX_PIPED_CHARS:]
+  if piped and prompt:
+    return f"```\n{piped.rstrip()}\n```\n\n{prompt}"
+  return prompt or piped
+
+
+def read_piped():
+  """Text piped into nock, or None. A closed or detached stdin (scripts, nohup, cron) counts as nothing piped."""
+  try:
+    if sys.stdin is None or sys.stdin.isatty():
+      return None
+    return sys.stdin.read() or None
+  except (OSError, ValueError):
+    return None
+
+
+def run(prompt, start_server):
+  piped = read_piped()
+  message = first_message(prompt, piped)
+  messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+  with start_server() as server:
+    if message:
+      messages.append({"role": "user", "content": message})
+      print(complete(server.url, messages, MAX_TOKENS, TEMPERATURE)["content"].strip())
+      return
+    # No question and nothing piped: a chat. The conversation is kept so follow-ups have context.
+    print("Nock Coder, offline. Type a question, or exit to quit.", file=sys.stderr)
+    while True:
+      try:
+        question = input("> ").strip()
+      except EOFError:
+        return
+      if question.lower() in EXIT_WORDS:
+        return
+      if not question:
+        continue
+      messages.append({"role": "user", "content": question})
+      reply = complete(server.url, messages, MAX_TOKENS, TEMPERATURE)["content"].strip()
+      messages.append({"role": "assistant", "content": reply})
+      print(reply + "\n")

{nock_cli-0.1.0 → nock_cli-0.3.0}/src/nock_cli/download.py

@@ -40,15 +40,28 @@ def download(url, target, label):
         handle.write(chunk)
         done += len(chunk)
         show_progress(label, done, total)
-  sys.stderr.write("\n")
+  if sys.stderr.isatty():
+    sys.stderr.write("\n")
   partial.replace(target)
   return target
 
 
+_last_logged_step = {}
+
+
 def show_progress(label, done, total):
+  """One updating line on a terminal; in a log file (no terminal) a line every 10%, so logs stay readable."""
   megabytes = done / 1048576
   if total:
-    sys.stderr.write(f"\r  {label}: {megabytes:,.0f} / {total / 1048576:,.0f} MB ({done * 100 // total}%)")
+    line = f"  {label}: {megabytes:,.0f} / {total / 1048576:,.0f} MB ({done * 100 // total}%)"
+  else:
+    line = f"  {label}: {megabytes:,.0f} MB"
+  if sys.stderr.isatty():
+    sys.stderr.write("\r" + line)
   else:
-    sys.stderr.write(f"\r  {label}: {megabytes:,.0f} MB")
+    step = done * 10 // total if total else int(megabytes // 500)
+    if _last_logged_step.get(label) == step:
+      return
+    _last_logged_step[label] = step
+    sys.stderr.write(line + "\n")
   sys.stderr.flush()