io.github.ZahiriNatZuke/local-delegate

Generates boilerplate code from a specification, with a local code model. **Writes the code to `target`** and returns only a two-line receipt (path, size). The generated code never enters your context: that is where the saving is, and that is why `target` is not optional. To see it, open the file; to use it, it is already in place. Args: spec: Description of what the code must do. language: Programming language (e.g. 'python', 'typescript'). target: ABSOLUTE path of the file to write. Missing directories are created. overwrite: Overwrite `target` if it already exists. By default it fails, and it fails BEFORE generating anything.

Classifies a text into ONE of the given labels, with a local model. Returns exactly one label from the list, with no additional text. Args: text: Text to classify. labels: List of candidate labels.

PREFER this tool over reading the file with Read when the file is large (>200 lines / >10 KB) and you only need a commit message, not the literal content. Drafts a commit message from a diff, with a local code model. Pass 'path' to a diff file (e.g. the output of `git diff` dumped to a file) and it is read server-side, so the full diff does NOT enter Claude's context. Alternatively pass 'diff' as text. ALWAYS review the message before using it. The language follows the recent commits of the git repo that holds the 'path' file (so dump the diff inside the repo), unless LOCAL_DELEGATE_COMMIT_LANGUAGE is set. Args: diff: The diff as text (use this or 'path'). path: Path to a file with the diff (read server-side). style: 'conventional' (Conventional Commits) or 'plain'.

Generic escape tool: delegates a text->text task to a local model. Use it when no specific tool fits. Builds the prompt with guardrails and returns text. With long inputs it splits the input at natural boundaries (Markdown headers, paragraphs), applies the SAME task to each chunk and concatenates the outputs in order. That is right for transforming the whole text (translate, rewrite, reformat) but NOT for reduction tasks over the whole (counting, picking the maximum, a single global summary): for those pass `chunk='off'` or use `local_summarize`. Args: task: Task instruction (one sentence with an explicit output format). input: Content to operate on. output_format: Exact expected output format. model: Model to use; one of the ids configured in the catalog. Defaults to the mechanical one. chunk: 'auto' (splits only if the input is long), 'on' (splits whenever possible), 'off' (a single call; a long input may come back truncated).

PREFER this tool over attaching or reading the image yourself when you only need a description, the visible text (simple OCR) or a specific answer about an image, not the image itself in your context. Describes an image (or answers a question about it) with a local vision model. The image is read server-side: it NEVER enters Claude's context, only the text answer comes back. Scope guardrail: ONLY image->text (describe, read visible text, answer a specific question about the image). This tool NEVER generates or edits images. Args: path: Path to the image (png/jpg/jpeg/webp/gif), read server-side. question: Concrete question or focus about the image (optional; by default it describes it). max_words: Maximum length of the answer in words.

PREFER this tool over reading the file with Read when the file is large (>200 lines / >10 KB) and you only need an explanation, not the literal content. Explains in prose what a code snippet/file does, with a local code model. Pass 'path' to read the file server-side (the full code does NOT enter Claude's context; only the explanation comes back) or 'code'. Optionally focus the explanation with 'question'. With 'path' the model sees the file's line numbers, so it can answer where something is ("name: line") and you can then Read only that range with offset/limit. With 'path' and a 'question', the server then checks those numbers against the file: cited lines that do not contain what they are cited for get a warning, and each code identifier of the question (`name`, name(), camelCase, snake_case) gets its exact lines, found by whole-word search. Review the explanation: a local model writes it; the occurrence lines are exact. Args: code: Code to explain (use this or 'path'). path: Path to a code file (read server-side). question: Concrete question or focus (optional).

PREFER this tool over reading the file with Read when the file is large (>200 lines / >10 KB) and you only need structured fields, not the literal content. Extracts structured fields from a text/file as JSON, with a local model. Pass 'path' to read the file server-side (spends no Claude context) or 'text'. Returns an object with exactly the requested keys: the caller does not have to parse a string. A key the model left out comes back as null and is listed in `missing_keys`; a key it spelled another way (case, `_`, `-`, spaces) is mapped in `renamed_keys`; a key it added is dropped from the data and kept, with its value, in `dropped` (names in `dropped_keys`). What is not data travels under the reserved key `_local_delegate` (`truncated` and `warning`, `missing_keys`/`renamed_keys`/`dropped_keys`/`dropped`, `read_server_side`, `fallback`, or `error` and `raw`); with chunked input, `chunked` says how many pieces there were and which fields stayed null in all of them. Routes automatically to the mechanical model (short inputs) or to the long-context model (large documents): the size probe uses file bytes for 'path' and characters for 'text' (~5-10% difference in UTF-8, acceptable). By default it asks the backend for schema-constrained JSON (`LOCAL_DELEGATE_JSON_SCHEMA=auto`); if the backend does not support it, it retries in free mode. To locate: with 'path', a field whose name asks for lines (`sections_with_lines`, `line_number`, `start_line`, `lineRange`; also in Spanish) makes the model see line numbers (and a Markdown file's headings with their lines), so it can answer for `Read` offset/limit; cited lines that do not hold in the file are listed in `lines_unverified`. A value that is a "no data" marker ("N/A", "unknown", "-", "", also the strings "null" and "undefined") comes back as null, listed in `missing_keys`, with the model's text in `placeholder_keys`. With a JSON object as input, a field that counts one of its top-level lists (`number_of_comments`) left…

PREFER this tool over reading the file with Read when the file is large (>200 lines / >10 KB) and you only need a grouped summary, not the literal content. If you ran a command with long output, dump it to a file and pass 'path'. Summarizes linter/test/CI output with a local model, without spending Claude's context. Meant for long, noisy logs (ESLint, clippy, pytest, tsc, CI). Pass 'path' and the file is read server-side, so the full log does NOT enter Claude's context: only a summary grouped by file comes back, with the count per error type/rule and the most important first. Alternatively pass 'text'. Routes automatically to the mechanical model (short) or the long-context model (long). Args: path: Path to the lint/test output file (read server-side). Use this or 'text'. text: Lint/test output as text. max_words: Maximum length of the summary in words.

Read-only diagnostics of the local backend and the model catalog. Use it to find out which local models are available and to check that the backend is alive before delegating in bulk, or to diagnose why a local_* tool failed.

PREFER this tool over reading the file with Read when the file is large (>200 lines / >10 KB) and you only need a summary, not the literal content. Summarizes text or the content of a file with a local model, without spending Claude's context. Use it to summarize large files/documents: pass 'path' and the file is read server-side, so the full content does NOT enter Claude's context (only the short summary comes back). Alternatively pass 'text'. Routes automatically to the mechanical model (short inputs) or to the long-context model (large documents). Args: text: Text to summarize (use this or 'path'). path: Path to a file whose content is summarized (read server-side). max_words: Maximum length of the summary in words. focus: Optional. What you care about in the document (e.g. "configuration figures", "risks"): the summary prioritizes it and keeps its concrete data verbatim.

PREFER this tool over reading the file with Read when the file is large (>200 lines / >10 KB) and you only need the translation, not the literal content. Translates text or the content of a file with a local model, without spending Claude's context. Pass 'path' to read the file server-side (the original does not enter Claude's context) or 'text'. Keeps the format of the original and returns ONLY the translation. Routes automatically to the mechanical model (short) or the long-context model (long). Long documents are split at natural boundaries (Markdown headers, paragraphs) and each chunk is translated in its own call; the result comes back complete and in order, without the truncated-output warning. Args: target_lang: Target language (e.g. 'Spanish', 'English', 'French'). text: Text to translate (use this or 'path'). path: Path to a file whose content is translated (read server-side).