dori 0.1.0__tar.gz

dori-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mauricio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dori-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include LICENSE
+include README.md
+include dori/tui.tcss
+recursive-include dori/boilerplate *

dori-0.1.0/PKG-INFO

@@ -0,0 +1,248 @@
+Metadata-Version: 2.4
+Name: dori
+Version: 0.1.0
+Summary: Dori terminal assistant
+Author: Mauricio
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mtdb/dori
+Project-URL: Repository, https://github.com/mtdb/dori
+Project-URL: Issues, https://github.com/mtdb/dori/issues
+Keywords: cli,local-first,ollama,terminal,assistant
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: User Interfaces
+Classifier: Topic :: Utilities
+Requires-Python: <4.0,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0.0
+Requires-Dist: ollama>=0.2.0
+Requires-Dist: textual>=0.52.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: ddgs<10,>=9.14.4
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Dynamic: license-file
+
+# Dori
+
+Dori is a local-first terminal assistant designed to work well with small local models.
+
+It is not trying to be "Claude Code, but local." The goal is narrower and more honest: help you from the terminal by routing clear requests into deterministic scripts, with behavior you can inspect, edit, and extend yourself.
+
+## What Dori Is
+
+- A terminal assistant that runs locally
+- A tool router that turns clear intents into structured JSON
+- A script-backed system you can customize in `~/.dori`
+- A better fit for 8B-class local models than open-ended autonomous agents
+
+## What Dori Is Not
+
+- Not a full autonomous coding agent
+- Not a replacement for larger hosted models on complex repo-wide tasks
+- Not a hidden tool loop that edits files and runs commands without a clear contract
+- Not magic: reliability matters more than agent theater
+
+If you expect broad autonomous code editing, long tool loops, or strong performance on hard software tasks with a small local model, Dori will probably feel intentionally constrained.
+
+## Why This Project Exists
+
+Most local assistants either:
+
+- imitate larger coding agents and become unreliable on small models, or
+- stay so simple that they are hard to extend into something genuinely useful.
+
+Dori aims for the middle:
+
+- local-first
+- fast to start
+- understandable
+- extendable with plain Markdown and Python
+- optimized for reliability over autonomy
+
+The model decides when a request matches a skill and fills structured arguments. A deterministic script does the real work.
+
+## Good Fit
+
+Dori is a good fit if you want:
+
+- a personal terminal assistant powered by Ollama
+- a system you can inspect and customize end to end
+- practical local workflows such as web lookup, reminders, calendar actions, git help, docker help, or folder analysis
+- predictable behavior from small local models
+
+Dori is a poor fit if you want:
+
+- a general-purpose coding agent with deep autonomy
+- multi-step repo mutation driven mostly by the model
+- the same capability level as Claude Code, Codex, or similar systems
+
+## How It Works
+
+1. Dori loads its persona from `~/.dori/DORI.md`.
+2. It discovers installed skills from `~/.dori/skills/`.
+3. The local model either answers normally or emits one JSON payload for a matching skill.
+4. Dori validates that payload and runs the matching script from `~/.dori/scripts/`.
+5. The script prints the result back to the user.
+
+This separation is the core idea:
+
+- skills teach the model when to act
+- scripts perform the action deterministically
+
+## Current Product Shape
+
+Today Dori includes:
+
+- a Textual TUI
+- one-off prompt mode with `dori --prompt`
+- direct skill execution with `dori <skill-name>`
+- local persona and skill loading from `~/.dori`
+- bundled starter skills for tasks like reminders, calendar, web, git, docker, commit, and folder analysis
+- update-safe boilerplate management through `dori init` and `dori update`
+
+## Requirements
+
+- Python 3.11+
+- Ollama running locally
+- a local model available in Ollama
+
+By default, Dori uses `llama3.1:8b`.
+
+## Quickstart
+
+1. Install:
+
+```bash
+pip install -e .
+```
+
+2. Initialize runtime files:
+
+```bash
+dori init
+```
+
+3. Start the assistant:
+
+```bash
+dori
+```
+
+4. Or send a single prompt:
+
+```bash
+dori --prompt "Summarize my open tasks"
+```
+
+## Global Install
+
+For a global CLI install, prefer `pipx`:
+
+```bash
+pipx install .
+```
+
+To track local development changes:
+
+```bash
+pipx install -e .
+```
+
+Alternative with user-local `pip`:
+
+```bash
+python3 -m pip install --user .
+```
+
+## Runtime Layout
+
+Dori stores its runtime state in `~/.dori`:
+
+```text
+~/.dori/
+|-- DORI.md
+|-- .manifest.json
+|-- .history
+|-- skills/
+`-- scripts/
+```
+
+`dori init` copies the bundled boilerplate into that directory and asks you to choose:
+
+- a reminders backend
+- a search backend
+
+`dori update` refreshes managed files that still match their last installed hash and preserves files you have edited locally.
+
+The TUI stores the last 100 submitted messages in `.history` so you can recall them with `↑` and `↓` in new sessions.
+
+## Search Backends
+
+Search defaults to DDGS for zero-key web answers.
+
+For Tavily-backed search, export:
+
+```bash
+export TAVILY_API_KEY="tvly-..."
+```
+
+For DDGS-backed search, Dori uses a local Ollama model to synthesize an English answer from retrieved evidence. Override that model with:
+
+```bash
+export DORI_WEB_MODEL="llama3.1:8b"
+```
+
+Both search backends return a direct answer followed by `Sources:` and two or three URLs.
+
+## Better Prompts With Ctrl+T
+
+Small local models often respond better to English prompts. The TUI includes a built-in translation shortcut:
+
+- press `Ctrl+T` while writing a message
+- Dori translates your draft into natural English before sending it
+
+It tries to preserve code, commands, flags, file paths, URLs, identifiers, and quoted literals.
+
+## Extending Dori
+
+The main customization story is intentionally simple:
+
+1. add a skill Markdown file under `~/.dori/skills/`
+2. add a same-named Python script under `~/.dori/scripts/`
+3. make the script read the JSON payload and print a clear result
+
+This makes Dori easier to inspect and evolve than systems that hide everything behind a large prompt or a complex agent runtime.
+
+## Development Notes
+
+- Public packaging and CLI surface are `dori`
+- Internal modules live under the `dori` package
+- Boilerplate and onboarding text should refer to Dori
+
+## Tests
+
+Run the default test suite:
+
+```bash
+poetry run pytest
+```
+
+Integration tests that call Ollama are skipped by default. To run them, make sure Ollama is running and `llama3.1:8b` is installed:
+
+```bash
+ollama pull llama3.1:8b
+DORI_RUN_OLLAMA_INTEGRATION=1 poetry run pytest tests/test_ollama_integration.py
+```
+
+The Ollama integration tests use `llama3.1:8b` with `seed: 42` and `temperature: 0` for predictable routing checks.

dori-0.1.0/README.md

@@ -0,0 +1,213 @@
+# Dori
+
+Dori is a local-first terminal assistant designed to work well with small local models.
+
+It is not trying to be "Claude Code, but local." The goal is narrower and more honest: help you from the terminal by routing clear requests into deterministic scripts, with behavior you can inspect, edit, and extend yourself.
+
+## What Dori Is
+
+- A terminal assistant that runs locally
+- A tool router that turns clear intents into structured JSON
+- A script-backed system you can customize in `~/.dori`
+- A better fit for 8B-class local models than open-ended autonomous agents
+
+## What Dori Is Not
+
+- Not a full autonomous coding agent
+- Not a replacement for larger hosted models on complex repo-wide tasks
+- Not a hidden tool loop that edits files and runs commands without a clear contract
+- Not magic: reliability matters more than agent theater
+
+If you expect broad autonomous code editing, long tool loops, or strong performance on hard software tasks with a small local model, Dori will probably feel intentionally constrained.
+
+## Why This Project Exists
+
+Most local assistants either:
+
+- imitate larger coding agents and become unreliable on small models, or
+- stay so simple that they are hard to extend into something genuinely useful.
+
+Dori aims for the middle:
+
+- local-first
+- fast to start
+- understandable
+- extendable with plain Markdown and Python
+- optimized for reliability over autonomy
+
+The model decides when a request matches a skill and fills structured arguments. A deterministic script does the real work.
+
+## Good Fit
+
+Dori is a good fit if you want:
+
+- a personal terminal assistant powered by Ollama
+- a system you can inspect and customize end to end
+- practical local workflows such as web lookup, reminders, calendar actions, git help, docker help, or folder analysis
+- predictable behavior from small local models
+
+Dori is a poor fit if you want:
+
+- a general-purpose coding agent with deep autonomy
+- multi-step repo mutation driven mostly by the model
+- the same capability level as Claude Code, Codex, or similar systems
+
+## How It Works
+
+1. Dori loads its persona from `~/.dori/DORI.md`.
+2. It discovers installed skills from `~/.dori/skills/`.
+3. The local model either answers normally or emits one JSON payload for a matching skill.
+4. Dori validates that payload and runs the matching script from `~/.dori/scripts/`.
+5. The script prints the result back to the user.
+
+This separation is the core idea:
+
+- skills teach the model when to act
+- scripts perform the action deterministically
+
+## Current Product Shape
+
+Today Dori includes:
+
+- a Textual TUI
+- one-off prompt mode with `dori --prompt`
+- direct skill execution with `dori <skill-name>`
+- local persona and skill loading from `~/.dori`
+- bundled starter skills for tasks like reminders, calendar, web, git, docker, commit, and folder analysis
+- update-safe boilerplate management through `dori init` and `dori update`
+
+## Requirements
+
+- Python 3.11+
+- Ollama running locally
+- a local model available in Ollama
+
+By default, Dori uses `llama3.1:8b`.
+
+## Quickstart
+
+1. Install:
+
+```bash
+pip install -e .
+```
+
+2. Initialize runtime files:
+
+```bash
+dori init
+```
+
+3. Start the assistant:
+
+```bash
+dori
+```
+
+4. Or send a single prompt:
+
+```bash
+dori --prompt "Summarize my open tasks"
+```
+
+## Global Install
+
+For a global CLI install, prefer `pipx`:
+
+```bash
+pipx install .
+```
+
+To track local development changes:
+
+```bash
+pipx install -e .
+```
+
+Alternative with user-local `pip`:
+
+```bash
+python3 -m pip install --user .
+```
+
+## Runtime Layout
+
+Dori stores its runtime state in `~/.dori`:
+
+```text
+~/.dori/
+|-- DORI.md
+|-- .manifest.json
+|-- .history
+|-- skills/
+`-- scripts/
+```
+
+`dori init` copies the bundled boilerplate into that directory and asks you to choose:
+
+- a reminders backend
+- a search backend
+
+`dori update` refreshes managed files that still match their last installed hash and preserves files you have edited locally.
+
+The TUI stores the last 100 submitted messages in `.history` so you can recall them with `↑` and `↓` in new sessions.
+
+## Search Backends
+
+Search defaults to DDGS for zero-key web answers.
+
+For Tavily-backed search, export:
+
+```bash
+export TAVILY_API_KEY="tvly-..."
+```
+
+For DDGS-backed search, Dori uses a local Ollama model to synthesize an English answer from retrieved evidence. Override that model with:
+
+```bash
+export DORI_WEB_MODEL="llama3.1:8b"
+```
+
+Both search backends return a direct answer followed by `Sources:` and two or three URLs.
+
+## Better Prompts With Ctrl+T
+
+Small local models often respond better to English prompts. The TUI includes a built-in translation shortcut:
+
+- press `Ctrl+T` while writing a message
+- Dori translates your draft into natural English before sending it
+
+It tries to preserve code, commands, flags, file paths, URLs, identifiers, and quoted literals.
+
+## Extending Dori
+
+The main customization story is intentionally simple:
+
+1. add a skill Markdown file under `~/.dori/skills/`
+2. add a same-named Python script under `~/.dori/scripts/`
+3. make the script read the JSON payload and print a clear result
+
+This makes Dori easier to inspect and evolve than systems that hide everything behind a large prompt or a complex agent runtime.
+
+## Development Notes
+
+- Public packaging and CLI surface are `dori`
+- Internal modules live under the `dori` package
+- Boilerplate and onboarding text should refer to Dori
+
+## Tests
+
+Run the default test suite:
+
+```bash
+poetry run pytest
+```
+
+Integration tests that call Ollama are skipped by default. To run them, make sure Ollama is running and `llama3.1:8b` is installed:
+
+```bash
+ollama pull llama3.1:8b
+DORI_RUN_OLLAMA_INTEGRATION=1 poetry run pytest tests/test_ollama_integration.py
+```
+
+The Ollama integration tests use `llama3.1:8b` with `seed: 42` and `temperature: 0` for predictable routing checks.

dori-0.1.0/dori/__init__.py

@@ -0,0 +1 @@
+"""Dori terminal assistant."""

dori-0.1.0/dori/boilerplate/DORI.md

@@ -0,0 +1,11 @@
+You are Dori, a locally running personal assistant in the terminal.
+
+- Be direct and concise.
+- When a user's intent clearly matches an available skill, respond with the required JSON payload only, with no preamble, explanation, or markdown.
+- Only express uncertainty when the task is genuinely ambiguous or the answer is factual and you are not confident.
+- If the request is ambiguous, ask a short follow-up question instead of guessing.
+- Otherwise, respond in plain text.
+
+# Language Flexibility
+
+- You may think and respond in English even if the user's question is in another language, especially if it helps you reason or provide a more accurate answer.

dori-0.1.0/dori/boilerplate/presets/reminders/dbus.md

@@ -0,0 +1,21 @@
+# D-Bus Reminders Preset
+
+**Intent**: Use when the user wants a local desktop reminder through D-Bus notifications.
+
+**Runtime guidance:**
+- Requires `notify-send` for real reminder scheduling.
+- Supports only relative times in seconds, minutes, or hours.
+- Use `dry_run` only for tests or previews where no desktop notification should be scheduled.
+
+**Field guidance:**
+- `message`: The task only — strip all time expressions and filler words (e.g. "drink water", not "remind me to drink water")
+- `when`: A supported relative time (e.g. "in 20 minutes", "in 2 hours", "in 30 seconds")
+- `confidence`: Numeric confidence from 0.0 to 1.0
+- `raw_text`: Copy the user's original message verbatim
+
+**Examples:**
+User: Remind me to drink water in 20 minutes
+Assistant: {"skill": "reminders", "confidence": 0.95, "message": "drink water", "when": "in 20 minutes", "raw_text": "Remind me to drink water in 20 minutes"}
+
+User: Set a timer to stretch in 2 hours
+Assistant: {"skill": "reminders", "confidence": 0.94, "message": "stretch", "when": "in 2 hours", "raw_text": "Set a timer to stretch in 2 hours"}

dori-0.1.0/dori/boilerplate/presets/reminders/dbus.py

@@ -0,0 +1,121 @@
+import json
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+RELATIVE_TIME_PATTERN = re.compile(
+    r"^\s*in\s+(\d+)\s+(seconds?|minutes?|hours?)\s*$",
+    re.IGNORECASE,
+)
+
+
+def parse_relative_seconds(when: str) -> int | None:
+    match = RELATIVE_TIME_PATTERN.match(when)
+    if not match:
+        return None
+
+    amount = int(match.group(1))
+    unit = match.group(2).lower()
+    if unit.startswith("second"):
+        return amount
+    if unit.startswith("minute"):
+        return amount * 60
+    if unit.startswith("hour"):
+        return amount * 60 * 60
+    return None
+
+
+def _notification_icon_path() -> Path | None:
+    script_dir = Path(__file__).resolve().parent
+    candidates = [
+        script_dir.parent / "assets" / "dori.png",
+        script_dir.parent.parent / "assets" / "dori.png",
+    ]
+    for candidate in candidates:
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+def _notify_send_command(message: str) -> list[str]:
+    command = ["notify-send"]
+    icon_path = _notification_icon_path()
+    if icon_path is not None:
+        command.extend(["-i", str(icon_path)])
+    command.extend(["Dori reminder", message])
+    return command
+
+
+def schedule_notification(message: str, delay_seconds: int) -> None:
+    icon_path = _notification_icon_path()
+    if icon_path is None:
+        code = (
+            "import subprocess, sys, time; "
+            "time.sleep(int(sys.argv[1])); "
+            'subprocess.run(["notify-send", "Dori reminder", sys.argv[2]], check=False)'
+        )
+        args = [sys.executable, "-c", code, str(delay_seconds), message]
+    else:
+        code = (
+            "import subprocess, sys, time; "
+            "time.sleep(int(sys.argv[1])); "
+            'subprocess.run(["notify-send", "-i", sys.argv[3], "Dori reminder", sys.argv[2]], check=False)'
+        )
+        args = [
+            sys.executable,
+            "-c",
+            code,
+            str(delay_seconds),
+            message,
+            str(icon_path),
+        ]
+    subprocess.Popen(
+        args,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True,
+    )
+
+
+def main() -> None:
+    if len(sys.argv) < 2:
+        print("Error: Missing JSON payload", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        payload = json.loads(sys.argv[1])
+    except json.JSONDecodeError:
+        print(
+            "Error: Invalid JSON payload provided to reminders script.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    message = payload.get("message", "unknown")
+    when = payload.get("when", "unknown time")
+    seconds = parse_relative_seconds(when)
+    if seconds is None:
+        print(
+            "Error: Unsupported reminder time. Use a relative time like "
+            "'in 20 minutes', 'in 2 hours', or 'in 30 seconds'.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    if not payload.get("dry_run", False):
+        if shutil.which("notify-send") is None:
+            print(
+                "Error: D-Bus reminders require notify-send to be installed.",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+
+        schedule_notification(str(message), seconds)
+
+    print(f"[D-Bus]: Scheduled reminder for '{message}' {when}.")
+
+
+if __name__ == "__main__":
+    main()

dori-0.1.0/dori/boilerplate/presets/reminders/template.md

@@ -0,0 +1,16 @@
+# Reminders Skill
+
+**Intent**: Use when the user wants to set a reminder, alarm, or timer.
+
+**Field guidance:**
+- `message`: The task only — strip all time expressions and filler words (e.g. "buy milk", not "remind me to buy milk tomorrow")
+- `when`: The time expression as spoken (e.g. "tomorrow at 9am", "in 20 minutes")
+- `confidence`: Numeric confidence from 0.0 to 1.0
+- `raw_text`: Copy the user's original message verbatim
+
+**Examples:**
+User: Remind me to buy milk in 20 minutes
+Assistant: {"skill": "reminders", "confidence": 0.95, "message": "buy milk", "when": "in 20 minutes", "raw_text": "Remind me to buy milk in 20 minutes"}
+
+User: Set an alarm for 7am tomorrow to wake up
+Assistant: {"skill": "reminders", "confidence": 0.94, "message": "wake up", "when": "7am tomorrow", "raw_text": "Set an alarm for 7am tomorrow to wake up"}

dori-0.1.0/dori/boilerplate/presets/reminders/template.py

@@ -0,0 +1,25 @@
+import json
+import sys
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Error: Missing JSON payload", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        payload = json.loads(sys.argv[1])
+        message = payload.get("message", "unknown")
+        when = payload.get("when", "unknown time")
+
+        # Deterministic output
+        print(f"⏰ [System]: I have scheduled a reminder for '{message}' at '{when}'.")
+    except json.JSONDecodeError:
+        print(
+            "Error: Invalid JSON payload provided to reminders script.", file=sys.stderr
+        )
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()