kiwi-ai 0.0.11__tar.gz

kiwi_ai-0.0.11/.github/workflows/publish.yml

@@ -0,0 +1,77 @@
+name: Publish to PyPI
+
+run-name: "Publish ${{ github.event.inputs.version && format('v{0}', github.event.inputs.version) || github.ref_name }}"
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Version to publish (e.g., 0.1.1)'
+        required: true
+        type: string
+  push:
+    tags:
+      - 'v*.*.*'
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+
+      - name: Set up Python
+        run: uv python install 3.13
+
+      - name: Determine version
+        id: version
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            echo "version=${{ github.event.inputs.version }}" >> "$GITHUB_OUTPUT"
+          else
+            # Extract version from tag (v0.1.1 -> 0.1.1)
+            TAG="${GITHUB_REF#refs/tags/v}"
+            echo "version=$TAG" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Update version in pyproject.toml
+        run: |
+          sed -i "s/^version = .*/version = \"${{ steps.version.outputs.version }}\"/" pyproject.toml
+          echo "Publishing version: ${{ steps.version.outputs.version }}"
+          grep '^version' pyproject.toml
+
+      - name: Install dependencies
+        run: uv sync
+
+      - name: Smoke test
+        env:
+          # Prevent any re-exec / process-renaming logic from interfering with CI.
+          _KIWI_PROC_RENAMED: "1"
+          KIWI_DISABLE_REEXEC: "1"
+        run: |
+          uv run kiwicli --help
+          uv run kiwi --help
+          uv run kiwi-runtime --help
+          uv run python -c "import kiwi_cli, kiwi_tui, kiwi_runtime; print('imports ok')"
+
+      - name: Build package
+        run: uv build
+
+      - name: Verify build artifacts
+        run: |
+          ls -lh dist/
+          # Check that the built version matches the expected version
+          EXPECTED="${{ steps.version.outputs.version }}"
+          if ! ls dist/ | grep -q "$EXPECTED"; then
+            echo "ERROR: Built artifacts do not contain expected version $EXPECTED"
+            ls dist/
+            exit 1
+          fi
+
+      - name: Publish to PyPI
+        env:
+          UV_PUBLISH_TOKEN: ${{ secrets.PYPI_TOKEN }}
+        run: uv publish

kiwi_ai-0.0.11/.github/workflows/test.yml

@@ -0,0 +1,45 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: tests-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    name: pytest · py${{ matrix.python-version }} · ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python-version: ["3.11", "3.12", "3.13"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+        with:
+          enable-cache: true
+
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Sync dependencies (with test group)
+        run: uv sync --python ${{ matrix.python-version }} --group test
+
+      - name: Run pytest
+        run: uv run --python ${{ matrix.python-version }} pytest -v --tb=short
+
+      - name: Entry-point smoke tests
+        run: |
+          uv run --python ${{ matrix.python-version }} kiwicli --help
+          uv run --python ${{ matrix.python-version }} kiwi-runtime --help
+        env:
+          _KIWI_PROC_RENAMED: "1"

kiwi_ai-0.0.11/.gitignore

@@ -0,0 +1,32 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Claude Code
+.claude/
+
+# Logs
+*.log
+
+# Local config & tokens
+.kiwi/

kiwi_ai-0.0.11/.python-version

@@ -0,0 +1 @@
+3.13

kiwi_ai-0.0.11/Makefile

@@ -0,0 +1,69 @@
+.PHONY: run dev serve cli runtime test-hello install sync clean help
+
+# Run the Kiwi TUI application
+run:
+	uv run kiwi
+
+# Run the Kiwi TUI application in development mode (with live reload and debugging)
+dev:
+	uv run --dev kiwi
+
+# Serve the Kiwi TUI in the browser via textual serve (e.g. make serve PORT=8566)
+serve:
+	uv run textual serve --port $(or $(PORT),8566) -c "python -m kiwi_tui.main"
+
+# Run the Kiwi CLI
+cli:
+	uv run kiwicli
+
+# Run the Kiwi Runtime agent (pass ARGS, e.g. make runtime ARGS="connect --server app")
+runtime:
+	uv run kiwi-runtime $(ARGS)
+
+# Test the hello API connection
+test-hello:
+	uv run python test_hello.py
+
+# Install/sync dependencies
+install:
+	uv sync
+
+# Sync dependencies
+sync:
+	uv sync
+
+# Clean up temporary files and caches
+clean:
+	find . -type d -name "__pycache__" -exec rm -rf {} + 2>/dev/null || true
+	find . -type f -name "*.pyc" -delete
+	find . -type f -name "*.pyo" -delete
+	find . -type f -name "*.log" -delete
+	rm -rf .pytest_cache
+	rm -rf .ruff_cache
+	rm -rf dist/
+	rm -rf build/
+	rm -rf *.egg-info
+
+# Build the package
+build:
+	uv build
+
+# Show help
+help:
+	@echo "Kiwi Code - Makefile Commands"
+	@echo ""
+	@echo "Usage: make [command]"
+	@echo ""
+	@echo "Commands:"
+	@echo "  run          - Run the Kiwi TUI application (kiwi)"
+	@echo "  dev          - Run TUI in development mode (with live reload)"
+	@echo "  serve        - Serve the TUI in the browser (PORT=8566 make serve)"
+	@echo "  cli          - Run the Kiwi CLI (kiwicli)"
+	@echo "  runtime      - Run the Kiwi Runtime agent (kiwi-runtime)"
+	@echo "                 e.g. make runtime ARGS=\"connect --server app\""
+	@echo "  test-hello   - Test connection to backend (hello API)"
+	@echo "  install      - Install/sync project dependencies"
+	@echo "  sync         - Sync dependencies"
+	@echo "  build        - Build the package"
+	@echo "  clean        - Clean up temporary files and caches"
+	@echo "  help         - Show this help message"

kiwi_ai-0.0.11/PKG-INFO

@@ -0,0 +1,429 @@
+Metadata-Version: 2.4
+Name: kiwi-ai
+Version: 0.0.11
+Summary: A textual-based terminal user interface application
+Project-URL: Homepage, https://kiwicode.ai
+Project-URL: Repository, https://github.com/runkailabs/kiwi-code
+Author-email: Anurag <anurag@runkai.ai>
+License: Proprietary
+Keywords: cli,terminal,textual,tui
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: <4.0,>=3.11
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: pykiwiai==0.0.11
+Requires-Dist: setproctitle>=1.3.0
+Requires-Dist: textual-dev>=1.8.0
+Requires-Dist: textual>=8.1.1
+Requires-Dist: typer>=0.24.1
+Requires-Dist: websockets>=14.1
+Requires-Dist: wonderwords>=2.2.0
+Description-Content-Type: text/markdown
+
+# Kiwi Code
+
+Kiwi Code is a terminal-first interface for chatting with **Kiwi Actions**, managing **runs** (action results), and connecting the **Kiwi Runtime** (a local CLI / terminal agent) so actions can execute terminal commands on your machine.
+
+Primary entrypoints:
+
+- **TUI:** `kiwi` (or `python -m kiwi_tui.main`)
+- **Terminal mode:** `kiwi --terminal ...`
+- **Inspection CLI:** `kiwicli` (optional; list/get style scripting)
+- **Runtime:** `kiwi-runtime`
+
+> Requires **Python 3.11+**.
+
+---
+
+## Quick start
+
+### 1) Install
+
+```bash
+pip install kiwi-code
+```
+
+### 2) Log in from the terminal
+
+```bash
+kiwi login
+```
+
+This prompts for your email and password and stores tokens at:
+
+- `~/.kiwi/tokens.json`
+
+You can inspect auth state anytime with:
+
+```bash
+kiwi whoami
+```
+
+To clear saved credentials:
+
+```bash
+kiwi logout
+```
+
+### 3) Launch the TUI (unchanged default)
+
+```bash
+kiwi
+```
+
+Or choose a server preset:
+
+```bash
+kiwi --server dev
+```
+
+Available presets:
+
+- `app` (prod)
+- `dev` (dev)
+- `local` (localhost)
+
+### 4) Use terminal mode instead of the full-screen TUI
+
+Fresh conversation on the default action:
+
+```bash
+kiwi --terminal "Hi, what are you doing?"
+```
+
+Fresh conversation for a specific action:
+
+```bash
+kiwi --terminal --action-id <ACTION_ID> "Inspect this repository"
+```
+
+Continue an existing run:
+
+```bash
+kiwi --terminal --run-id <RUN_ID> "What changed?"
+```
+
+Pipe the message on stdin:
+
+```bash
+echo "Summarize the latest output" | kiwi --terminal --run-id <RUN_ID>
+```
+
+Connect the local CLI runtime from terminal mode:
+
+```bash
+kiwi --terminal --connect-cli
+kiwi --terminal --connect-cli --action-id <ACTION_ID>
+kiwi --terminal --connect-cli --run-id <RUN_ID>
+```
+
+Rules:
+
+- `kiwi` by itself still launches the TUI.
+- `--action-id` starts a **fresh** conversation for that action.
+- `--run-id` continues an **existing** run.
+- `--action-id` and `--run-id` are mutually exclusive.
+- `--connect-cli` cannot be combined with a user message.
+
+### 5) (Optional) Start the runtime manually
+
+In most cases, let Kiwi manage the runtime automatically via `/connect-cli` in the TUI or `kiwi --terminal --connect-cli` in terminal mode.
+
+If you want to run it yourself:
+
+```bash
+kiwi-runtime connect --server dev --scope restricted --allow "$PWD"
+```
+
+---
+
+## Terminal mode usage
+
+### Human-readable output
+
+```bash
+kiwi --terminal "Hello"
+```
+
+This prints the run result directly in your terminal.
+
+### JSON output for scripts
+
+```bash
+kiwi --terminal --json --action-id <ACTION_ID> "Hello"
+```
+
+### Disable live status streaming
+
+```bash
+kiwi --terminal --no-stream --run-id <RUN_ID> "Continue this task"
+```
+
+### Authentication in terminal mode
+
+If you are not logged in, terminal mode exits with a helpful message telling you to run:
+
+```bash
+kiwi login
+```
+
+---
+
+## Daily workflow (TUI)
+
+### Pick an action → chat
+
+- `/actions list` → pick an action
+- Type a message and press Enter
+
+### Start a fresh conversation
+
+- `/new` resets the chat to the default action and clears history in the UI.
+
+### Continue an existing run (conversation)
+
+- `/runs list` → pick a run
+- or `/continue <run_id>`
+
+Kiwi Code will load the conversation history for that run.
+
+---
+
+## Local CLI agent (Runtime)
+
+Some actions can execute terminal commands via a local runtime process.
+
+### Connect the runtime to the current run
+
+From the TUI:
+
+- `/connect-cli`
+
+From terminal mode:
+
+```bash
+kiwi --terminal --connect-cli
+kiwi --terminal --connect-cli --action-id <ACTION_ID>
+kiwi --terminal --connect-cli --run-id <RUN_ID>
+```
+
+What it does:
+
+- Ensures a local runtime exists **for the current run_id**.
+- If the runtime was disconnected (e.g. after a server redeploy), Kiwi Code detects it and starts a fresh one.
+- Sends the instruction prompt: `Connect to the CLI right now before asking or doing anything.`
+- In terminal mode, `--connect-cli` is a setup action only, so it **must not** be combined with a message.
+
+### View runtime logs
+
+- Slash command: `/show-logs`
+- Keyboard shortcut: **Ctrl+O** (works even while the chat input is disabled / streaming)
+
+### Runtime lifecycle
+
+- Runtime processes are tracked under `~/.kiwi/runtimes/`.
+- Runtimes are **per run_id** (one runtime process per run).
+- Runtimes may survive TUI restarts.
+- On quit (`Ctrl+C`), Kiwi Code shows an exit prompt listing runtimes and lets you choose which to kill.
+
+---
+
+## Keyboard shortcuts (TUI)
+
+These are designed to work even when input is blocked during streaming.
+
+| Key | Action |
+|---|---|
+| `Ctrl+C` | Quit (shows runtime cleanup prompt if runtimes are alive) |
+| `Ctrl+O` | Open CLI logs (`/show-logs`) |
+| `Ctrl+G` | Open slash-command picker (`/ ...`) |
+| `Ctrl+U` | Attach files / content (`@ ...`) |
+| `Ctrl+J` | Send message |
+
+---
+
+## Slash commands (TUI)
+
+### Session
+
+- `/use <action_id>` — switch action (starts a **fresh chat UI**)
+- `/actions list` — list & select actions
+- `/new` — new conversation (default action)
+- `/continue <run_id>` — continue an existing run and load history
+- `/runs list` — list & select runs
+- `/status` — show current action/run ids
+
+### Files
+
+- `@` opens the inline file picker
+- `/upload <path> [path2 ...]` uploads files and attaches them to your next message
+- `/files` shows pending attachments
+- `/clear-files` clears pending attachments
+
+### Runtime
+
+- `/connect-cli` — ensure runtime exists (per run_id) + send “connect” prompt
+- `/show-logs` — open runtime logs screen
+
+---
+
+## CLI overview
+
+### `kiwi`
+
+`kiwi` is the primary user-facing CLI.
+
+Examples:
+
+```bash
+kiwi
+kiwi login
+kiwi whoami
+kiwi --terminal "Hello"
+kiwi --terminal --connect-cli --run-id <RUN_ID>
+```
+
+### `kiwicli`
+
+`kiwicli` remains available for list/get style scripting and inspection.
+
+Examples:
+
+```bash
+kiwicli actions list
+kiwicli actions get <action_id>
+
+kiwicli runs list --status processing
+kiwicli runs get <run_id>
+```
+
+---
+
+## Server / flags
+
+`kiwi` / `python -m kiwi_tui.main` supports runtime flags (mirrors `kiwi-runtime connect`). These flags are used whenever Kiwi Code needs to start a runtime, whether you are in the TUI or terminal mode.
+
+```bash
+kiwi --server dev \
+  --scope restricted \
+  --allow /some/extra/dir
+```
+
+Terminal mode examples:
+
+```bash
+kiwi --terminal --server dev "Hello"
+kiwi --terminal --json --action-id <ACTION_ID> "Hello"
+kiwi --terminal --no-stream --run-id <RUN_ID> "Continue"
+```
+
+- `--server`: `app | dev | local | <full url>`
+- `--scope`: `restricted | full`
+- `--allow PATH`: repeatable; additional allowed directories in restricted mode
+- `--terminal`: run Kiwi in plain terminal mode instead of the full-screen TUI
+- `--action-id`: start a fresh conversation for the given action
+- `--run-id`: continue an existing run
+- `--connect-cli`: ensure runtime exists and send the connect prompt
+- `--json`: print machine-readable output for terminal mode
+- `--no-stream`: wait for the final result without live status streaming
+
+> Note: Kiwi Code does **not** modify the runtime implementation under `src/kiwi_runtime/`.
+
+---
+
+## Using `kiwi-runtime` standalone (advanced)
+
+You can run the Kiwi Runtime by itself (without the TUI). This is useful for:
+- debugging runtime connectivity / permissions
+- keeping a long-lived runtime running in a separate terminal tab
+- watching runtime activity/logs directly
+
+### Start the runtime
+
+If you installed kiwi-code as a package:
+
+```bash
+kiwi-runtime connect --server dev --scope restricted --allow "$PWD"
+```
+
+From the repo (recommended for development):
+
+```bash
+uv run python -m kiwi_runtime.main connect --server dev --scope restricted --allow "$PWD"
+```
+
+Notes:
+- `--server` supports presets: `app`, `dev`, `local` (or a full URL).
+- `--scope restricted` is the default; use `--allow` to add directories.
+- The runtime prints connection status and will remain running until you stop it.
+
+### Authentication
+
+The runtime typically needs an access token. When you run the TUI and log in, your token is saved to:
+- `~/.kiwi/tokens.json`
+
+You can pass the token explicitly (if required by your setup):
+
+```bash
+kiwi-runtime connect --server dev --token <ACCESS_TOKEN>
+```
+
+### Stop the runtime
+
+Press **Ctrl+C** in the runtime terminal to disconnect and exit.
+
+### Important behavior when running standalone
+
+- Standalone runtimes are **not tracked** in `~/.kiwi/runtimes/` (that directory is used by kiwi-code to track TUI-managed runtimes).
+- If you run the TUI and then run `/connect-cli`, kiwi-code may start its own runtime process if it doesn’t detect a managed runtime for the current run.
+  - For normal usage, prefer letting the TUI manage the runtime via `/connect-cli`.
+  - For standalone/debug usage, run `kiwi-runtime connect ...` in a separate terminal and use it to observe activity.
+
+---
+
+## Troubleshooting
+
+### “CLI runtime stopped responding” after server redeploy
+
+If the backend restarts (common in `dev`), the runtime websocket may close.
+
+Fix:
+1. In Kiwi Code, run `/connect-cli` again.
+2. If needed, open logs (Ctrl+O) to confirm the new runtime connected.
+
+Kiwi Code validates existing runtime processes and will restart them when they’re invalid/disconnected.
+
+### Quit shows a runtime cleanup prompt
+
+This is expected. Select runtimes to kill (or press Esc to keep them running).
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/jetoslabs/kiwi-code.git
+cd kiwi-code
+uv sync
+uv run python -m kiwi_tui.main --server dev
+```
+
+Run tests:
+
+```bash
+uv run python -m pytest -q
+```
+
+---
+
+## License
+
+Proprietary. All rights reserved.