codicent-cli 0.7.1__tar.gz → 0.8.0__tar.gz

{codicent_cli-0.7.1 → codicent_cli-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codicent-cli
-Version: 0.7.1
+Version: 0.8.0
 Summary: Command-line interface for the Codicent API
 Home-page: https://github.com/izaxon/codicent-cli
 Author: Johan Isaksson
@@ -27,6 +27,7 @@ Requires-Dist: rich
 Requires-Dist: codicent-py
 Requires-Dist: prompt_toolkit
 Requires-Dist: requests
+Requires-Dist: pyyaml
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -104,6 +105,28 @@ pip install git+https://github.com/izaxon/codicent-cli.git@v0.4.8
    export CODICENT_TOKEN="YOUR_API_TOKEN"
    ```
 
+   Or use the built-in device-flow authentication:
+   ```bash
+   codicent auth          # stores token globally in ~/.codicent_token
+   codicent auth --local  # stores token in .codicent_token in the current directory
+   ```
+
+### Per-folder Projects
+
+You can have a different Codicent project per directory by storing a local token:
+
+```bash
+cd ~/work/projectA
+codicent auth --local   # authenticates and saves token to ~/work/projectA/.codicent_token
+
+cd ~/work/projectB
+codicent auth --local   # authenticates and saves token to ~/work/projectB/.codicent_token
+```
+
+The CLI always checks the current directory first, then falls back to the global `~/.codicent_token`, and finally to the `CODICENT_TOKEN` environment variable.
+
+> **Tip**: Add `.codicent_token` to your `.gitignore` to avoid accidentally committing tokens.
+
 ### Command Options
 
 ```
@@ -211,6 +234,102 @@ The CLI provides helpful error messages for common issues:
 - **Input validation**: Prevents empty or overly long inputs
 - **Keyboard interrupts**: Clean exit handling
 
+## Project Init
+
+Use `codicent init` to instantly set up a new project from a template. Each template posts a ready-to-use set of AI instructions, configuration, automation rules, and sample data.
+
+```bash
+codicent init --list                              # list templates
+codicent init                                     # use default template
+codicent init --template koi-studio              # CRM pipeline
+codicent init --template document-processing     # document intake
+codicent init --template koi-studio --dry-run    # preview without posting
+codicent init --force                            # re-init even if already set up
+```
+
+### Available templates
+
+| Template | Description |
+|---|---|
+| `default` | General-purpose: task workflow, auto-summarize notes via `#transform` |
+| `koi-studio` | CRM: automatic lead extraction from raw text, follow-up email drafting |
+| `document-processing` | Document intake: extract text, structure key fields with AI, review workflow |
+
+### How it works
+
+Templates are JSON files in `templates/`. Each defines:
+- **`variables`** — prompted at init time (e.g. company name). Values with defaults are applied silently; values without defaults require manual entry.
+- **`messages`** — posted in order. Each has an optional `label` shown in progress output.
+
+Key message types posted by templates:
+- `#instructions` — sets the AI assistant's persona and focus
+- `#appconfig #data` — configures AI model, temperature, and token limit
+- `#process #data` — defines pipeline stages (shown as kanban columns in the UI)
+- `#transform #data` — automation rule: when a message with tag X arrives, run AI and produce a message with tag Y
+- sample `#data` messages — so lists aren't empty on first login
+
+### `--dry-run` mode
+
+Prints every message that *would* be posted, with its label and a content preview, without any API calls or auth required. Useful for reviewing a template before committing.
+
+## Wrap — AI CLI Remote Chat Bridge
+
+Use `codicent wrap` to bridge a local AI CLI tool (`claude`, `codex`, `opencode`, etc.) to your codicent project chat. Remote users and the Codicent AI can interact with the locally running tool in real time through the existing codicent web UI.
+
+```bash
+codicent wrap claude                              # wrap Claude Code
+codicent wrap opencode                            # wrap OpenCode
+codicent wrap --label "Refactor sprint" codex     # named session
+codicent wrap --poll-interval 5 claude            # slower polling
+codicent wrap --binary /opt/ai/claude claude      # explicit binary path
+```
+
+### How it works
+
+1. Starts the specified tool as a local subprocess with full stdin/stdout control.
+2. Opens a **session** tagged `#wrap #wrap_<id>` in your codicent project.
+3. **Output** from the tool is captured and posted to codicent tagged `#wrap #wrap_<id> #output`.
+4. **Input** is received by polling for messages tagged `#wrap #wrap_<id> #input` — any message posted remotely with those tags is forwarded to the tool's stdin.
+
+The session ID is printed on startup. To send text to the running tool from the codicent web UI, post a message with `#wrap_<id> #input` in the content.
+
+### Startup output
+
+```
+🔗 Wrap session starting…
+   Session ID: wrap_a3f7c1b2
+   Project:    myproject
+   Tool:       claude  (/usr/local/bin/claude)
+   Remote tag: #wrap_a3f7c1b2
+   Post messages tagged #wrap_a3f7c1b2 #input to send text to the tool.
+   Press Ctrl+C to stop the session.
+```
+
+### Configuration (`~/.codicent/wrap-config.yaml`)
+
+```yaml
+poll_interval: 2          # seconds between input polls
+output_batch_ms: 500      # ms to batch output before posting
+
+tools:
+  claude:
+    binary: claude        # binary name or full path
+  codex:
+    binary: codex
+  opencode:
+    binary: opencode
+
+auto_responses:
+  - pattern: "Do you want to continue"
+    reply: "y"
+  - pattern: "\\(y/n\\)"
+    reply: "y"
+```
+
+Auto-response rules are matched against subprocess output using regex. When matched, the configured reply is written to stdin automatically (and posted to codicent for visibility).
+
+If no config file exists, defaults are used: tools are resolved by name on `$PATH`, poll interval is 2 seconds.
+
 ## Development
 
 ### Running Tests
@@ -222,6 +341,7 @@ python -m pytest test_app.py -v
 ### Project Structure
 
 - `app.py` - Main application logic (single-file architecture)
+- `wrap.py` - Wrap command: AI CLI remote chat bridge
 - `test_app.py` - Comprehensive test suite
 - `setup.py` - Package configuration
 - `requirements.txt` - Dependencies (now uses PyPI packages)
@@ -230,6 +350,7 @@ python -m pytest test_app.py -v
 
 - **codicent-py**: Core API client for Codicent services (now available on PyPI)
 - **rich**: Terminal formatting, markdown rendering, and animations
+- **pyyaml**: YAML config file parsing for the wrap command
 
 ## Troubleshooting
 

{codicent_cli-0.7.1 → codicent_cli-0.8.0}/README.md

@@ -62,6 +62,28 @@ pip install git+https://github.com/izaxon/codicent-cli.git@v0.4.8
    export CODICENT_TOKEN="YOUR_API_TOKEN"
    ```
 
+   Or use the built-in device-flow authentication:
+   ```bash
+   codicent auth          # stores token globally in ~/.codicent_token
+   codicent auth --local  # stores token in .codicent_token in the current directory
+   ```
+
+### Per-folder Projects
+
+You can have a different Codicent project per directory by storing a local token:
+
+```bash
+cd ~/work/projectA
+codicent auth --local   # authenticates and saves token to ~/work/projectA/.codicent_token
+
+cd ~/work/projectB
+codicent auth --local   # authenticates and saves token to ~/work/projectB/.codicent_token
+```
+
+The CLI always checks the current directory first, then falls back to the global `~/.codicent_token`, and finally to the `CODICENT_TOKEN` environment variable.
+
+> **Tip**: Add `.codicent_token` to your `.gitignore` to avoid accidentally committing tokens.
+
 ### Command Options
 
 ```
@@ -169,6 +191,102 @@ The CLI provides helpful error messages for common issues:
 - **Input validation**: Prevents empty or overly long inputs
 - **Keyboard interrupts**: Clean exit handling
 
+## Project Init
+
+Use `codicent init` to instantly set up a new project from a template. Each template posts a ready-to-use set of AI instructions, configuration, automation rules, and sample data.
+
+```bash
+codicent init --list                              # list templates
+codicent init                                     # use default template
+codicent init --template koi-studio              # CRM pipeline
+codicent init --template document-processing     # document intake
+codicent init --template koi-studio --dry-run    # preview without posting
+codicent init --force                            # re-init even if already set up
+```
+
+### Available templates
+
+| Template | Description |
+|---|---|
+| `default` | General-purpose: task workflow, auto-summarize notes via `#transform` |
+| `koi-studio` | CRM: automatic lead extraction from raw text, follow-up email drafting |
+| `document-processing` | Document intake: extract text, structure key fields with AI, review workflow |
+
+### How it works
+
+Templates are JSON files in `templates/`. Each defines:
+- **`variables`** — prompted at init time (e.g. company name). Values with defaults are applied silently; values without defaults require manual entry.
+- **`messages`** — posted in order. Each has an optional `label` shown in progress output.
+
+Key message types posted by templates:
+- `#instructions` — sets the AI assistant's persona and focus
+- `#appconfig #data` — configures AI model, temperature, and token limit
+- `#process #data` — defines pipeline stages (shown as kanban columns in the UI)
+- `#transform #data` — automation rule: when a message with tag X arrives, run AI and produce a message with tag Y
+- sample `#data` messages — so lists aren't empty on first login
+
+### `--dry-run` mode
+
+Prints every message that *would* be posted, with its label and a content preview, without any API calls or auth required. Useful for reviewing a template before committing.
+
+## Wrap — AI CLI Remote Chat Bridge
+
+Use `codicent wrap` to bridge a local AI CLI tool (`claude`, `codex`, `opencode`, etc.) to your codicent project chat. Remote users and the Codicent AI can interact with the locally running tool in real time through the existing codicent web UI.
+
+```bash
+codicent wrap claude                              # wrap Claude Code
+codicent wrap opencode                            # wrap OpenCode
+codicent wrap --label "Refactor sprint" codex     # named session
+codicent wrap --poll-interval 5 claude            # slower polling
+codicent wrap --binary /opt/ai/claude claude      # explicit binary path
+```
+
+### How it works
+
+1. Starts the specified tool as a local subprocess with full stdin/stdout control.
+2. Opens a **session** tagged `#wrap #wrap_<id>` in your codicent project.
+3. **Output** from the tool is captured and posted to codicent tagged `#wrap #wrap_<id> #output`.
+4. **Input** is received by polling for messages tagged `#wrap #wrap_<id> #input` — any message posted remotely with those tags is forwarded to the tool's stdin.
+
+The session ID is printed on startup. To send text to the running tool from the codicent web UI, post a message with `#wrap_<id> #input` in the content.
+
+### Startup output
+
+```
+🔗 Wrap session starting…
+   Session ID: wrap_a3f7c1b2
+   Project:    myproject
+   Tool:       claude  (/usr/local/bin/claude)
+   Remote tag: #wrap_a3f7c1b2
+   Post messages tagged #wrap_a3f7c1b2 #input to send text to the tool.
+   Press Ctrl+C to stop the session.
+```
+
+### Configuration (`~/.codicent/wrap-config.yaml`)
+
+```yaml
+poll_interval: 2          # seconds between input polls
+output_batch_ms: 500      # ms to batch output before posting
+
+tools:
+  claude:
+    binary: claude        # binary name or full path
+  codex:
+    binary: codex
+  opencode:
+    binary: opencode
+
+auto_responses:
+  - pattern: "Do you want to continue"
+    reply: "y"
+  - pattern: "\\(y/n\\)"
+    reply: "y"
+```
+
+Auto-response rules are matched against subprocess output using regex. When matched, the configured reply is written to stdin automatically (and posted to codicent for visibility).
+
+If no config file exists, defaults are used: tools are resolved by name on `$PATH`, poll interval is 2 seconds.
+
 ## Development
 
 ### Running Tests
@@ -180,6 +298,7 @@ python -m pytest test_app.py -v
 ### Project Structure
 
 - `app.py` - Main application logic (single-file architecture)
+- `wrap.py` - Wrap command: AI CLI remote chat bridge
 - `test_app.py` - Comprehensive test suite
 - `setup.py` - Package configuration
 - `requirements.txt` - Dependencies (now uses PyPI packages)
@@ -188,6 +307,7 @@ python -m pytest test_app.py -v
 
 - **codicent-py**: Core API client for Codicent services (now available on PyPI)
 - **rich**: Terminal formatting, markdown rendering, and animations
+- **pyyaml**: YAML config file parsing for the wrap command
 
 ## Troubleshooting
 

{codicent_cli-0.7.1 → codicent_cli-0.8.0}/app.py

@@ -40,8 +40,10 @@ OPTIONS:
 
 AUTHENTICATION:
     auth                Authenticate using device flow (project selected during web auth)
-    logout              Clear stored authentication
-    status              Check authentication status
+    auth --local        Authenticate and store token in the current directory (.codicent_token)
+    logout              Clear stored global authentication
+    logout --local      Clear only the local (.codicent_token) token in the current directory
+    status              Check authentication status (shows whether local or global token is used)
 
 FILE UPLOAD:
     upload              Upload files and post messages with tags
@@ -55,13 +57,54 @@ FILE UPLOAD:
     PROJECT INIT:
     init                Initialize current project with a template
     
-        --list              List available templates
+        --list              List available templates with descriptions
         --template NAME     Use a specific template (default: 'default')
+        --dry-run           Preview messages without posting (no auth needed)
+        --force             Re-initialize even if project already has #instructions
+    
+    Templates:
+        default             General-purpose: task workflow + auto-summarize notes
+        koi-studio          CRM: lead extraction + follow-up email drafting pipeline
+        document-processing Document intake: extract, structure, and review documents
     
     Examples:
         codicent init
         codicent init --template koi-studio
+        codicent init --template document-processing --dry-run
         codicent init --list
+        codicent init --force
+
+WRAP (AI CLI Remote Bridge):
+    wrap                Bridge a local AI CLI tool to a remote codicent chat session.
+                        Remote users and AI can interact with the locally running tool.
+    
+        <tool>              Tool to wrap: claude, codex, opencode, or any CLI tool
+        [tool-args...]      Arguments passed through to the wrapped tool
+        --label TEXT        Session label shown in codicent UI (default: "<tool> session")
+        --binary PATH       Explicit path to the tool binary
+        --poll-interval N   Seconds between input polls (default: 2)
+    
+    How it works:
+        1. Starts the tool as a local subprocess
+        2. Posts tool output to codicent tagged #wrap #wrap_<id> #output
+        3. Polls for messages tagged #wrap #wrap_<id> #input and writes them to stdin
+        4. Remote users tag messages with #wrap_<id> #input to send text to the tool
+    
+    Config file (~/.codicent/wrap-config.yaml):
+        poll_interval: 2
+        output_batch_ms: 500
+        tools:
+          claude:
+            binary: claude
+        auto_responses:
+          - pattern: "Do you want to continue"
+            reply: "y"
+    
+    Examples:
+        codicent wrap claude
+        codicent wrap --label "Refactor session" opencode
+        codicent wrap --poll-interval 5 codex
+        codicent wrap --binary /usr/local/bin/claude claude --model claude-opus-4-5
 
 EXAMPLES:
     codicent auth
@@ -70,6 +113,7 @@ EXAMPLES:
     codicent "@mention Hello there"
     codicent upload document.txt *.log
     codicent init --template koi-studio
+    codicent wrap claude
     echo "Help me debug this" | codicent
 
 ENVIRONMENT:
@@ -81,7 +125,7 @@ For more information, visit: https://github.com/izaxon/codicent-cli
 
 def show_version():
     """Display version information."""
-    print("Codicent CLI v0.7.1")
+    print("Codicent CLI v0.8.0")
 
 def validate_input(question):
     """Validate user input."""
@@ -115,6 +159,11 @@ def main():
         logging.getLogger().setLevel(logging.ERROR)
         sys.argv.remove("--quiet")
     
+    # Parse --local flag (store/remove token in current working directory)
+    use_local = "--local" in sys.argv
+    if use_local:
+        sys.argv.remove("--local")
+    
     # Initialize auth handler
     auth = CodicentAuth()
     
@@ -123,8 +172,7 @@ def main():
         command = sys.argv[1]
         
         if command == "auth":
-            # No project parameter needed - user selects project during web authorization
-            token = auth.get_token(force_reauth=True)
+            token = auth.get_token(force_reauth=True, local=use_local)
             if token:
                 console.print("[green]✅ Authentication successful![/green]")
                 return 0
@@ -133,13 +181,13 @@ def main():
                 return 1
         
         elif command == "logout":
-            auth.logout()
+            auth.logout(local=use_local)
             return 0
         
         elif command == "status":
-            token = auth.get_cached_token()
-            if token:
-                console.print("[green]✅ Authenticated (cached token available)[/green]")
+            source = auth.get_token_source()
+            if source:
+                console.print(f"[green]✅ Authenticated[/green] [dim]({source})[/dim]")
                 return 0
             else:
                 env_token = os.getenv("CODICENT_TOKEN")
@@ -270,6 +318,9 @@ def main():
     if len(sys.argv) > 1 and sys.argv[1] == "init":
         templates_dir = os.path.join(os.path.dirname(__file__), "templates")
 
+        dry_run = "--dry-run" in sys.argv
+        force = "--force" in sys.argv
+
         # --list: show available templates
         if "--list" in sys.argv:
             try:
@@ -279,7 +330,10 @@ def main():
                     template_path = os.path.join(templates_dir, f"{name}.json")
                     with open(template_path, encoding="utf-8") as fh:
                         meta = json.load(fh)
-                    console.print(f"  [bold bright_cyan]{name}[/bold bright_cyan] — {meta.get('description', '')}")
+                    vars_info = ""
+                    if meta.get("variables"):
+                        vars_info = f" [dim]({len(meta['variables'])} variable(s))[/dim]"
+                    console.print(f"  [bold bright_cyan]{name}[/bold bright_cyan]{vars_info} — {meta.get('description', '')}")
             except Exception as e:
                 console.print(f"[red]❌ Error listing templates: {e}[/red]")
             return 0
@@ -299,6 +353,51 @@ def main():
             console.print(f"[red]❌ Template '{template_name}' not found. Use 'codicent init --list' to see options.[/red]")
             return 1
 
+        with open(template_path, encoding="utf-8") as fh:
+            template = json.load(fh)
+
+        # Resolve variables: prompt for any without defaults
+        variable_values = {}
+        template_variables = template.get("variables", {})
+        for var_name, var_meta in template_variables.items():
+            default = var_meta.get("default", "")
+            description = var_meta.get("description", var_name)
+            if dry_run:
+                # In dry-run, use defaults without prompting
+                variable_values[var_name] = default or f"{{{var_name}}}"
+            elif default:
+                variable_values[var_name] = default
+                console.print(f"[dim]  {var_name}: {default} (default)[/dim]")
+            else:
+                value = input(f"  {description}: ").strip()
+                if not value:
+                    console.print(f"[red]❌ Variable '{var_name}' is required.[/red]")
+                    return 1
+                variable_values[var_name] = value
+
+        def apply_variables(text, project):
+            result = text.replace("{project}", project)
+            for var_name, var_value in variable_values.items():
+                result = result.replace("{" + var_name + "}", var_value)
+            return result
+
+        # --- Dry-run mode: print plan without calling API ---
+        if dry_run:
+            messages = template.get("messages", [])
+            console.print(f"\n[bold]Dry run — template [bright_cyan]{template_name}[/bright_cyan] ({len(messages)} messages)[/bold]")
+            console.print(f"[dim]No messages will be posted. Remove --dry-run to execute.[/dim]\n")
+            for i, entry in enumerate(messages, 1):
+                label = entry.get("label", f"Message {i}")
+                content = apply_variables(entry["content"], "{project}")
+                # Show first 120 chars of content
+                preview = content.replace("\n", "  ↵  ")
+                if len(preview) > 120:
+                    preview = preview[:117] + "..."
+                console.print(f"  [bold]{i}.[/bold] [bright_cyan]{label}[/bright_cyan]")
+                console.print(f"     [dim]{preview}[/dim]")
+            console.print()
+            return 0
+
         # Get authentication token
         token = auth.get_cached_token()
         if not token:
@@ -325,23 +424,41 @@ def main():
             console.print(f"[red]❌ Failed to initialize Codicent API client: {e}[/red]")
             return 1
 
-        with open(template_path, encoding="utf-8") as fh:
-            template = json.load(fh)
+        # Idempotency check: warn if #instructions already exists in this project
+        if not force:
+            try:
+                headers = {"Authorization": f"Bearer {token}"}
+                check_url = f"{codicent.base_url}api/GetMessages"
+                resp = requests.get(
+                    check_url,
+                    params={"mention": project, "tags": "instructions", "length": "1"},
+                    headers=headers,
+                    verify=codicent.verify_https,
+                    timeout=10,
+                )
+                if resp.ok and resp.json():
+                    console.print(f"[yellow]⚠ Project [bold]{project}[/bold] already has #instructions — it may have been initialized before.[/yellow]")
+                    console.print("[dim]Pass --force to initialize anyway, or --dry-run to preview what would be posted.[/dim]")
+                    return 1
+            except Exception:
+                logger.debug("Idempotency check failed (skipping)")
 
         messages = template.get("messages", [])
         console.print(f"Initializing [bold]{project}[/bold] with template [bold bright_cyan]{template_name}[/bold bright_cyan] ({len(messages)} messages)...")
 
         posted = 0
         failed = 0
-        for entry in messages:
-            content = entry["content"].replace("{project}", project)
+        for i, entry in enumerate(messages, 1):
+            label = entry.get("label", f"Message {i}")
+            content = apply_variables(entry["content"], project)
             msg_type = entry.get("type", "info")
             try:
-                with console.status(f"[dim]Posting message {posted + 1}/{len(messages)}...[/dim]", spinner="dots"):
+                with console.status(f"[dim]({i}/{len(messages)}) {label}...[/dim]", spinner="dots"):
                     codicent.post_message(content, type=msg_type)
+                console.print(f"  [green]✓[/green] [dim]{label}[/dim]")
                 posted += 1
             except Exception as e:
-                console.print(f"[red]❌ Failed to post message: {e}[/red]")
+                console.print(f"  [red]✗ {label}: {e}[/red]")
                 failed += 1
 
         console.print()
@@ -350,6 +467,38 @@ def main():
             console.print(f"[red]❌ {failed} message(s) failed.[/red]")
         return 0 if failed == 0 else 1
 
+    # Handle wrap command
+    if len(sys.argv) > 1 and sys.argv[1] == "wrap":
+        from wrap import run_wrap_command
+
+        wrap_token = auth.get_cached_token()
+        if not wrap_token:
+            wrap_token = os.getenv("CODICENT_TOKEN")
+        if not wrap_token:
+            console.print("[red]❌ No authentication found.[/red]")
+            console.print("[dim]Run 'codicent auth' to authenticate, or set CODICENT_TOKEN environment variable[/dim]")
+            return 1
+
+        # Extract project and base_url from JWT token
+        try:
+            wrap_payload = wrap_token.split(".")[1]
+            wrap_payload += '=' * (-len(wrap_payload) % 4)
+            wrap_jwt = json.loads(base64.urlsafe_b64decode(wrap_payload).decode('utf-8'))
+            wrap_project = wrap_jwt["project"]
+            wrap_base_url = wrap_jwt.get("baseUrl", "https://codicent.com/")
+        except Exception as e:
+            console.print(f"[red]❌ Failed to extract project from token: {e}[/red]")
+            return 1
+
+        # Pass everything after "wrap" as args
+        wrap_args = sys.argv[2:]
+        return run_wrap_command(
+            args=wrap_args,
+            token=wrap_token,
+            base_url=wrap_base_url,
+            project=wrap_project,
+        )
+
     # Get authentication token
     token = auth.get_cached_token()
     if not token:
@@ -578,7 +727,7 @@ def main():
 
         header = Text()
         header.append("Codicent CLI", style="bold bright_cyan")
-        header.append(" v0.7.1\n", style="bright_cyan")
+        header.append(" v0.8.0\n", style="bright_cyan")
         header.append("Type your questions or use Ctrl+C to exit.\n", style="dim")
         header.append("\n")
         header.append("Tip: ", style="bold dim")