GRAFT Code desktop app for Windows

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+GRAFT-Code.exe filter=lfs diff=lfs merge=lfs -text

GRAFT-Code.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:509d96a2ccdae3d96908905e7f646140ad20a81fac609fe8ea562fcb249b8484
+size 41694754

README.md

@@ -0,0 +1,88 @@
+---
+license: apache-2.0
+language:
+- en
+tags:
+- windows
+- desktop-app
+- agent
+- tool-calling
+- llama.cpp
+- gguf
+- local-ai
+---
+
+# GRAFT Code
+
+**A local AI agent for Windows that actually does things.** GRAFT Code is a desktop app that runs a GRAFT model on
+your own PC and lets it work on your files: it makes folders, writes and reads files, moves, renames, copies and
+deletes things, runs commands and Python, does exact math, and searches and reads the web. Every change asks you
+first. Nothing leaves your computer except web-search keywords.
+
+Made by **SmallAICreator / UltraLabs**.
+
+| File | What it is |
+|---|---|
+| `GRAFT-Code.exe` | GRAFT Code for **Windows 10/11** (x64, runs on CPU). llama.cpp is bundled. |
+| `graft-bridge/` | Optional: a Claude Code skill that lets GRAFT ask Claude for help (`talk_to_claude`). |
+
+## Pick a model
+
+| Model | Size | Best for |
+|---|---|---|
+| [GRAFT-10B-A2B](https://huggingface.co/SmallAICreator/GRAFT-10B-A2B-GGUF) | 6.3 GB, 16 GB RAM | The smartest option: a 10B mixture-of-experts with only 2B active, perfect recall up to 32K tokens |
+| [GRAFT-1B-Agentic](https://huggingface.co/SmallAICreator/GRAFT-1B-Agentic) | 1 GB, 8 GB RAM | Fast and light, tuned for tool use |
+
+Put the `.gguf` in your **Downloads** folder and GRAFT Code finds it.
+
+## Get started
+
+1. Download `GRAFT-Code.exe` and a model (above).
+2. Double-click the EXE. It's unsigned, so Windows SmartScreen may warn you: click *More info → Run anyway*.
+3. Wait for the model to load. The first launch reads GRAFT's instructions once (about 2 minutes on a laptop CPU with
+   the 10B). Later launches restore them from disk in seconds.
+4. Type what you want done, for example *"make a Python script that renames all my photos by date"*.
+
+It needs Microsoft Edge WebView2, which Windows 10 and 11 already have. GRAFT works in `~/GRAFT-Workspace`; change
+the folder from the sidebar.
+
+## Features
+
+- **Clean chat window** with light and dark themes. Replies stream in live, with formatted text and code blocks you
+  can copy.
+- **Tool cards and approvals.** Each action (write, run, search…) shows up as a card you can expand. Changes need an
+  approval: **Yes**, **Yes, and don't ask again** or **No, tell GRAFT what to do instead**.
+- **Model picker.** Searches every `.gguf` in your Downloads, Desktop, Documents and LM Studio folders, has
+  *Browse…* for anything else, and reopens the last model you used.
+- **Personas.** GRAFT, Coder, Playful, Concise and Teacher, or make your own with an emoji. Each persona has its own
+  system prompt and sampling settings.
+- **Settings.**
+  - *Sampling:* temperature, top-p, top-k, min-p, repeat penalty and reply length.
+  - *Model:* context size (up to what the model supports), CPU threads and the draft model.
+  - *Agent:* max steps, command timeout, auto-approve and full access.
+- **Chat history.** Every chat is saved in the sidebar. Reopen one and GRAFT remembers it.
+- **Copy, Regenerate and a context gauge** that shows how much of GRAFT's memory the chat uses.
+- **Speculative decoding.** If a matching draft model (`GRAFT-10B-A2B-draft-*.gguf`) sits next to GRAFT-10B-A2B,
+  GRAFT Code uses it automatically for faster replies.
+- **Use the model from other apps.** While GRAFT Code is open, its model is also an OpenAI-compatible API at
+  `http://127.0.0.1:1337/v1`. Other apps get their own slot, so they never slow GRAFT down by wiping its cache.
+- **Web search and page reading.** Just ask. It uses DuckDuckGo with Wikipedia as a backup, and no API key is needed.
+- **GRAFT.md notes.** Facts about your PC and how you like things done, read at the start of every chat.
+
+## Talk to Claude (optional)
+
+Copy the `graft-bridge` folder to `~/.claude/skills/`. In a Claude Code window, type `/graft-bridge`. Then tell GRAFT
+*"ask Claude …"*: the question goes to that Claude Code window, and Claude's answer comes back to GRAFT.
+
+## Where things are stored
+
+Everything stays in `%LOCALAPPDATA%\GRAFTCode`: settings (`config.json`), personas, saved chats, your `GRAFT.md` notes
+and the saved instruction cache.
+
+## Good to know
+
+- GRAFT Code runs real commands on your computer. Keep approvals on unless you trust the task.
+- Only run one big model at a time. Two copies of a 10B model won't fit in 16 GB of RAM.
+- Small models can make mistakes or make up results. Check anything important.
+
+GRAFT Code bundles [llama.cpp](https://github.com/ggml-org/llama.cpp) (MIT).

graft-bridge/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: graft-bridge
+description: Listen for questions from GRAFT Code's talk_to_claude tool (GRAFT-1B running locally) and answer them from this Claude Code session. Use when the user types /graft-bridge or asks Claude to listen for / answer GRAFT.
+---
+
+# GRAFT bridge — answer GRAFT-1B from this Claude Code session
+
+GRAFT Code (a local GRAFT-1B agent) has a `talk_to_claude` tool. It drops questions into
+`%LOCALAPPDATA%\GRAFTCode\bridge\` and waits (up to 10 min) for an answer file. `graft_bridge.py` lives in this
+skill's folder (`~/.claude/skills/graft-bridge/graft_bridge.py`).
+
+## Start listening
+Run with the Bash tool and `run_in_background: true` (keeps a heartbeat so GRAFT Code knows you're there; exits as
+soon as a question arrives, which wakes you up):
+
+```
+python ~/.claude/skills/graft-bridge/graft_bridge.py wait
+```
+
+Tell the user in one line that the bridge is on.
+
+## When it wakes you (background task completed)
+1. Read the task output: `GRAFT QUESTION` + JSON with `id`, `message` (what GRAFT asks), `user_request` (what the
+   user typed to GRAFT — answer THIS if GRAFT garbled the question), and `cwd`.
+2. Answer for a 1B model: short, plain, concrete (exact commands / code it can copy), under ~150 words unless code is
+   needed. GRAFT runs Windows PowerShell commands in `cwd`.
+3. Send it (text on stdin):
+   ```
+   python ~/.claude/skills/graft-bridge/graft_bridge.py answer <id> <<'EOF'
+   ...answer...
+   EOF
+   ```
+4. Show the user the question and your answer briefly, then restart the listener (step "Start listening").
+
+## Stop
+`python ~/.claude/skills/graft-bridge/graft_bridge.py stop` and stop the background task.

graft-bridge/graft_bridge.py

@@ -0,0 +1,74 @@
+r"""
+GRAFT <-> Claude Code bridge (the Claude side). GRAFT Code's talk_to_claude tool drops questions in
+%LOCALAPPDATA%\GRAFTCode\bridge\ ; a Claude Code session runs `wait` in the background, gets woken when a question
+arrives, and replies with `answer`. By SmallAICreator / UltraLabs.
+
+  py graft_bridge.py wait                 block (with heartbeat) until a question is waiting, print it, exit
+  py graft_bridge.py answer <id> < text   send the answer for question <id> (text on stdin)
+  py graft_bridge.py pending              list unanswered questions
+  py graft_bridge.py stop                 mark the listener as gone
+"""
+import json, os, sys, time
+from pathlib import Path
+
+BRIDGE = Path(os.environ.get("LOCALAPPDATA", str(Path.home()))) / "GRAFTCode" / "bridge"
+LISTENER = BRIDGE / "listener.json"
+
+
+def atomic_write(p, obj):
+    tmp = p.with_suffix(".tmp")
+    tmp.write_text(json.dumps(obj, ensure_ascii=False, indent=1), encoding="utf-8")
+    os.replace(tmp, p)
+
+
+def pending():
+    out = []
+    for q in sorted(BRIDGE.glob("q_*.json"), key=lambda p: p.stat().st_mtime):
+        qid = q.stem[2:]
+        if not (BRIDGE / f"a_{qid}.json").exists():
+            try:
+                out.append(json.loads(q.read_text(encoding="utf-8")))
+            except Exception:                                       # half-written: pick it up next poll
+                pass
+    return out
+
+
+def beat(state):
+    atomic_write(LISTENER, {"state": state, "ts": time.time(), "pid": os.getpid()})
+
+
+def main():
+    BRIDGE.mkdir(parents=True, exist_ok=True)
+    cmd = sys.argv[1] if len(sys.argv) > 1 else "wait"
+    if cmd == "wait":
+        while True:
+            qs = pending()
+            if qs:
+                beat("handling")                                    # GRAFT Code treats this as "Claude is on it"
+                q = qs[0]
+                print("GRAFT QUESTION")
+                print(json.dumps(q, ensure_ascii=False, indent=1))
+                if len(qs) > 1:
+                    print(f"({len(qs) - 1} more waiting)")
+                return
+            beat("listening")
+            time.sleep(1.0)
+    elif cmd == "answer":
+        qid = sys.argv[2]
+        text = sys.stdin.buffer.read().decode("utf-8", "replace").strip()   # raw bytes: Windows stdin mangles emoji
+        if not (BRIDGE / f"q_{qid}.json").exists():
+            sys.exit(f"no question {qid}")
+        atomic_write(BRIDGE / f"a_{qid}.json", {"id": qid, "answer": text, "time": time.time()})
+        beat("listening")
+        print(f"answered {qid} ({len(text)} chars)")
+    elif cmd == "pending":
+        print(json.dumps(pending(), ensure_ascii=False, indent=1))
+    elif cmd == "stop":
+        LISTENER.unlink(missing_ok=True)
+        print("listener stopped")
+    else:
+        sys.exit(__doc__)
+
+
+if __name__ == "__main__":
+    main()