ai-code-connect 0.2.0

package/README.md

@@ -0,0 +1,330 @@
+# AIC² - AI Code Connect
+
+```
+ █████╗ ██╗ ██████╗ ██████╗
+██╔══██╗██║██╔════╝ ╚════██╗
+██║  ██║██║██║       █████╔╝
+███████║██║██║      ██╔═══╝
+██╔══██║██║██║      ███████╗
+██║  ██║██║██║      ╚══════╝
+██║  ██║██║╚██████╗
+╚═╝  ╚═╝╚═╝ ╚═════╝
+```
+
+A CLI tool that connects **Claude Code** and **Gemini CLI**, eliminating manual copy-paste between AI coding assistants.
+
+**AIC²** = **A**I **C**ode **C**onnect (the two C's = ²)
+
+## The Problem
+
+When working with multiple AI coding tools:
+1. Ask Gemini for a proposal
+2. Copy the response
+3. Paste into Claude for review
+4. Copy Claude's feedback
+5. Paste back to Gemini...
+
+This is tedious and breaks your flow.
+
+## The Solution
+
+`aic` bridges both tools in a single interactive session with:
+- **Persistent sessions** - Both tools remember context
+- **One-command forwarding** - Send responses between tools instantly
+- **Interactive mode** - Full access to slash commands and approvals
+- **Detach/reattach** - Keep tools running in background
+
+## Installation
+
+```bash
+npm install -g ai-code-connect
+```
+
+That's it! The `aic` command is now available globally.
+
+### Alternative: Install from Source
+
+```bash
+git clone https://github.com/jacob-bd/ai-code-connect.git
+cd ai-code-connect
+npm install
+npm run build
+npm link
+```
+
+## Prerequisites
+
+Install both AI CLI tools:
+
+- **Claude Code**: `npm install -g @anthropic-ai/claude-code`
+- **Gemini CLI**: `npm install -g @google/gemini-cli`
+
+Verify:
+```bash
+aic tools
+# Should show both as "✓ available"
+```
+
+## Quick Start
+
+```bash
+aic
+```
+
+That's it! This launches the interactive session.
+
+## Usage
+
+### Basic Commands
+
+| Command | Description |
+|---------|-------------|
+| `/claude` | Switch to Claude Code |
+| `/claude -i` | Switch to Claude Code and enter interactive mode |
+| `/gemini` | Switch to Gemini CLI |
+| `/gemini -i` | Switch to Gemini CLI and enter interactive mode |
+| `/i` | Enter interactive mode (full tool access) |
+| `/forward` | Forward last response to other tool (auto-selects if 2 tools) |
+| `/forward [tool]` | Forward to specific tool (required if 3+ tools) |
+| `/forward [tool] [msg]` | Forward with additional context |
+| `/forward -i [tool]` | Forward and stay in interactive mode |
+| `/forwardi [tool]` | Same as `/forward -i` (alias: `/fwdi`) |
+| `/history` | Show conversation history |
+| `/status` | Show running processes |
+| `/clear` | Clear sessions and history |
+| `/quit` or `/cya` | Exit |
+
+### Tool Slash Commands
+
+Use double slash (`//`) to run tool-specific slash commands:
+
+| Input | What Happens |
+|-------|--------------|
+| `//cost` | Opens interactive mode, runs `/cost`, you see output |
+| `//status` | Opens interactive mode, runs `/status`, you can interact |
+| `//config` | Opens interactive mode, runs `/config`, full control |
+
+When you type `//command`:
+1. AIC enters interactive mode with the tool
+2. Sends the `/command` for you
+3. You see the full output and can interact
+4. Press `Ctrl+]` when done to return to AIC
+
+This approach ensures you can fully view and interact with commands like `/status` that show interactive UIs.
+
+### Command Menu
+
+Type `/` to see a command menu. Use ↓ arrow to select, or keep typing.
+
+### Example Session
+
+```
+❯ claude → How should I implement caching for this API?
+
+⠹ Claude is thinking...
+I suggest implementing a Redis-based caching layer...
+
+❯ claude → /forward What do you think of this approach?
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+↗ Forwarding from Claude Code → Gemini CLI
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Gemini CLI responds:
+
+The Redis approach is solid. I'd also consider...
+
+❯ gemini → /claude
+● Switched to Claude Code
+
+❯ claude → Can you implement that?
+```
+
+### Interactive Mode
+
+For full tool access (approvals, multi-turn interactions, etc.):
+
+```bash
+❯ claude → /i
+
+▶ Starting Claude Code interactive mode...
+Press Ctrl+] to detach • /exit to terminate
+
+> (interact with Claude directly)
+> (press Ctrl+])           # Detach back to aic
+
+⏸ Detached from Claude Code (still running)
+Use /i to re-attach
+
+❯ claude → /i              # Re-attach to same session
+↩ Re-attaching to Claude Code...
+```
+
+**Key bindings in interactive mode:**
+- `Ctrl+]` - Detach (tool keeps running)
+- `/exit` - Terminate the tool session
+
+> **Tip:** Use `//status` or `//cost` to quickly run tool commands—AIC will enter interactive mode, run the command, and you press `Ctrl+]` when done.
+
+> **Note:** Messages exchanged while in interactive mode (after `/i`) are not captured for forwarding. Use regular mode for conversations you want to forward between tools.
+
+### Interactive Forwarding
+
+When forwarding a message that might trigger permissions or require interaction (e.g., code edits, file changes), use `/forwardi` or `/forward -i` to stay in interactive mode:
+
+```bash
+❯ claude → /forwardi gemini
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+↗ Forwarding from Claude Code → Gemini CLI (interactive)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Gemini CLI responds:
+
+> I'll implement those changes. Allow me to edit src/api.ts? [y/n]: y
+> (you can respond to prompts)
+> (press Ctrl+] when done to return to aic)
+```
+
+This is useful when:
+- The AI might request permission to modify files
+- You need to approve or deny actions
+- The response requires multi-turn interaction
+
+### Session Persistence
+
+Sessions persist automatically within an AIC² session:
+- **Claude**: Uses unique session IDs (`--session-id` / `--resume`) isolated from other Claude instances
+- **Gemini**: Uses `--resume latest` flag
+
+Your conversation context is maintained across messages within the same AIC² session.
+
+## CLI Options
+
+```bash
+aic                         # Launch interactive session
+aic tools                   # List available AI tools
+aic config default          # Show current default tool
+aic config default gemini   # Set Gemini as default tool
+aic --version               # Show version
+aic --help                  # Show help
+```
+
+## Configuration
+
+### Default Tool
+
+Set which tool loads by default when you start AIC²:
+
+**Option 1: CLI command**
+```bash
+aic config default gemini
+```
+
+**Option 2: Inside AIC²**
+```
+❯ claude → /default gemini
+✓ Default tool set to "gemini". Will be used on next launch.
+```
+
+**Option 3: Environment variable (temporary override)**
+```bash
+AIC_DEFAULT_TOOL=gemini aic
+```
+
+Configuration is stored in `~/.aic/config.json`.
+
+## Architecture
+
+```
+src/
+├── adapters/
+│   ├── base.ts              # ToolAdapter interface & registry
+│   ├── claude.ts            # Claude Code adapter
+│   ├── gemini.ts            # Gemini CLI adapter
+│   ├── index.ts             # Exports all adapters
+│   └── template.ts.example  # Template for new adapters
+├── sdk-session.ts           # Interactive session & command handling
+├── persistent-pty.ts        # Persistent PTY management for tools
+├── index.ts                 # CLI entry point
+├── config.ts                # Configuration management (~/.aic/)
+├── utils.ts                 # Utilities (command execution, etc.)
+└── version.ts               # Version from package.json
+```
+
+## Adding New Tools
+
+AIC² is modular. To add a new AI CLI (e.g., OpenAI Codex):
+
+1. Copy the template: `cp src/adapters/template.ts.example src/adapters/codex.ts`
+2. Implement the `ToolAdapter` interface
+3. Register in `src/adapters/index.ts` and `src/index.ts`
+4. Add to `src/sdk-session.ts`
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed instructions.
+
+## Features
+
+- ✅ **Colorful UI** - ASCII banner, colored prompts, status indicators
+- ✅ **Rainbow animations** - Animated rainbow effect on slash commands
+- ✅ **Spinner** - Visual feedback while waiting for responses
+- ✅ **Session persistence** - Context maintained across messages
+- ✅ **Interactive mode** - Full tool access with detach/reattach
+- ✅ **Command menu** - Type `/` for autocomplete suggestions
+- ✅ **Forward responses** - One command to send between tools
+- ✅ **Modular adapters** - Easy to add new AI tools
+- ✅ **Cross-platform** - Works on macOS, Linux, and Windows
+- ✅ **Request locking** - Prevents concurrent request issues
+- ✅ **Memory safe** - Conversation history limits prevent memory leaks
+
+## Development
+
+```bash
+# Development mode
+npm run dev
+
+# Build
+npm run build
+
+# Run
+aic
+```
+
+## Testing
+
+AIC² uses [Vitest](https://vitest.dev/) for testing.
+
+```bash
+# Run tests once
+npm test
+
+# Run tests in watch mode (re-runs on file changes)
+npm run test:watch
+```
+
+### What's Tested
+
+| File | Tests | Description |
+|------|-------|-------------|
+| `src/utils.test.ts` | 17 | Pure utility functions: `stripAnsi`, `truncate`, `formatResponse` |
+| `src/config.test.ts` | 18 | Config loading, saving, defaults, environment variable handling |
+
+### Adding Tests
+
+Test files live alongside source files with a `.test.ts` suffix:
+- `src/utils.ts` → `src/utils.test.ts`
+- `src/config.ts` → `src/config.test.ts`
+
+Tests are excluded from the build output (`dist/`) but are committed to git.
+
+## Vibe Coding Alert
+
+Full transparency: this project was built by a non-developer using AI coding assistants (yes, the very tools this project connects). If you're an experienced developer or architect, you might look at this codebase and wince. That's okay.
+
+The goal here was to scratch an itch and learn along the way. The code works, but it's likely missing patterns, optimizations, or elegance that only years of experience can provide.
+
+**This is where you come in.** If you see something that makes you cringe, please consider contributing rather than just closing the tab. This is open source specifically because human expertise is irreplaceable. Whether it's refactoring, performance improvements, better error handling, or architectural guidance - PRs and issues are welcome.
+
+Think of it as a chance to mentor an AI-assisted developer through code review. We all benefit when experienced developers share their knowledge.
+
+## License
+
+MIT

package/dist/adapters/base.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Base interface for AI CLI tool adapters
+ */
+export interface SendOptions {
+    /** Working directory for the tool */
+    cwd?: string;
+    /** Whether to continue the previous session (default: true) */
+    continueSession?: boolean;
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Keep stdin open after command (for interactive sessions) */
+    keepStdinOpen?: boolean;
+}
+export interface ToolAdapter {
+    /** Unique name identifier for the tool */
+    readonly name: string;
+    /** Display name for the tool */
+    readonly displayName: string;
+    /** ANSI color code for the tool (e.g., '\x1b[96m' for bright cyan) */
+    readonly color: string;
+    /** Regex pattern to detect when tool is showing its input prompt (ready for input) */
+    readonly promptPattern: RegExp;
+    /** Fallback timeout in ms - if no output for this long, assume response complete */
+    readonly idleTimeout: number;
+    /** Time in ms to wait for tool to start before sending commands (first launch) */
+    readonly startupDelay: number;
+    /** Check if the tool is installed and available */
+    isAvailable(): Promise<boolean>;
+    /** Send a prompt to the tool and get a response */
+    send(prompt: string, options?: SendOptions): Promise<string>;
+    /** Reset conversation context */
+    resetContext(): void;
+    /** Get the command that would be executed (for debugging) */
+    getCommand(prompt: string, options?: SendOptions): string[];
+    /** Get the command to start an interactive session */
+    getInteractiveCommand(options?: SendOptions): string[];
+    /** Get arguments for starting a persistent PTY session */
+    getPersistentArgs(): string[];
+    /** Clean response output - remove UI noise like spinners, prompts, status lines */
+    cleanResponse(rawOutput: string): string;
+    /** Check if there's an active session with this tool */
+    hasSession(): boolean;
+    /** Set whether there's an active session (for persistence) */
+    setHasSession(value: boolean): void;
+}
+/**
+ * Registry of available tool adapters
+ */
+export declare class AdapterRegistry {
+    private adapters;
+    register(adapter: ToolAdapter): void;
+    get(name: string): ToolAdapter | undefined;
+    getAll(): ToolAdapter[];
+    getNames(): string[];
+    getAvailable(): Promise<ToolAdapter[]>;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/adapters/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/adapters/base.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,qCAAqC;IACrC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,+DAA+D;IAC/D,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,8BAA8B;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+DAA+D;IAC/D,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,WAAW;IAC1B,0CAA0C;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,gCAAgC;IAChC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAE7B,sEAAsE;IACtE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,sFAAsF;IACtF,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAE/B,oFAAoF;IACpF,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAE7B,kFAAkF;IAClF,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B,mDAAmD;IACnD,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAEhC,mDAAmD;IACnD,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAE7D,iCAAiC;IACjC,YAAY,IAAI,IAAI,CAAC;IAErB,6DAA6D;IAC7D,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE,CAAC;IAE5D,sDAAsD;IACtD,qBAAqB,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE,CAAC;IAEvD,0DAA0D;IAC1D,iBAAiB,IAAI,MAAM,EAAE,CAAC;IAE9B,mFAAmF;IACnF,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAEzC,wDAAwD;IACxD,UAAU,IAAI,OAAO,CAAC;IAEtB,8DAA8D;IAC9D,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;CACrC;AAED;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAuC;IAEvD,QAAQ,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAIpC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAI1C,MAAM,IAAI,WAAW,EAAE;IAIvB,QAAQ,IAAI,MAAM,EAAE;IAId,YAAY,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;CAS7C"}

package/dist/adapters/base.js

@@ -0,0 +1,28 @@
+/**
+ * Registry of available tool adapters
+ */
+export class AdapterRegistry {
+    adapters = new Map();
+    register(adapter) {
+        this.adapters.set(adapter.name, adapter);
+    }
+    get(name) {
+        return this.adapters.get(name);
+    }
+    getAll() {
+        return Array.from(this.adapters.values());
+    }
+    getNames() {
+        return Array.from(this.adapters.keys());
+    }
+    async getAvailable() {
+        const available = [];
+        for (const adapter of this.adapters.values()) {
+            if (await adapter.isAvailable()) {
+                available.push(adapter);
+            }
+        }
+        return available;
+    }
+}
+//# sourceMappingURL=base.js.map

package/dist/adapters/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sourceRoot":"","sources":["../../src/adapters/base.ts"],"names":[],"mappings":"AA6DA;;GAEG;AACH,MAAM,OAAO,eAAe;IAClB,QAAQ,GAA6B,IAAI,GAAG,EAAE,CAAC;IAEvD,QAAQ,CAAC,OAAoB;QAC3B,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC3C,CAAC;IAED,GAAG,CAAC,IAAY;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAED,MAAM;QACJ,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED,QAAQ;QACN,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IAC1C,CAAC;IAED,KAAK,CAAC,YAAY;QAChB,MAAM,SAAS,GAAkB,EAAE,CAAC;QACpC,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;YAC7C,IAAI,MAAM,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC;gBAChC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC1B,CAAC;QACH,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;CACF"}

package/dist/adapters/claude.d.ts

@@ -0,0 +1,45 @@
+import { ToolAdapter, SendOptions } from './base.js';
+/**
+ * Adapter for Claude Code CLI
+ *
+ * Claude Code supports:
+ * - Non-interactive mode via -p/--print flag
+ * - Output formats: text, json, stream-json
+ * - Session continuation via --session-id (isolated from other sessions in same directory)
+ */
+export declare class ClaudeAdapter implements ToolAdapter {
+    readonly name = "claude";
+    readonly displayName = "Claude Code";
+    readonly color = "\u001B[96m";
+    readonly promptPattern: RegExp;
+    readonly idleTimeout = 3000;
+    readonly startupDelay = 2500;
+    private hasActiveSession;
+    private sessionId;
+    private sessionCreated;
+    isAvailable(): Promise<boolean>;
+    /**
+     * Get or create a unique session ID for aic's Claude sessions.
+     * This isolates aic from other Claude Code sessions in the same directory.
+     */
+    private getOrCreateSessionId;
+    /**
+     * Get session args for Claude commands.
+     * First call uses --session-id to CREATE the session.
+     * Subsequent calls use --resume to CONTINUE the session (avoids "already in use" errors).
+     */
+    private getSessionArgs;
+    getCommand(prompt: string, options?: SendOptions): string[];
+    getInteractiveCommand(options?: SendOptions): string[];
+    getPersistentArgs(): string[];
+    cleanResponse(rawOutput: string): string;
+    send(prompt: string, options?: SendOptions): Promise<string>;
+    resetContext(): void;
+    /** Check if there's an active session */
+    hasSession(): boolean;
+    /** Mark that a session exists (for loading from persisted state) */
+    setHasSession(value: boolean): void;
+    /** Get current session ID (for debugging/logging) */
+    getSessionId(): string | null;
+}
+//# sourceMappingURL=claude.d.ts.map

package/dist/adapters/claude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude.d.ts","sourceRoot":"","sources":["../../src/adapters/claude.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAGrD;;;;;;;GAOG;AACH,qBAAa,aAAc,YAAW,WAAW;IAC/C,QAAQ,CAAC,IAAI,YAAY;IACzB,QAAQ,CAAC,WAAW,iBAAiB;IACrC,QAAQ,CAAC,KAAK,gBAAc;IAI5B,QAAQ,CAAC,aAAa,SAAwB;IAI9C,QAAQ,CAAC,WAAW,QAAQ;IAG5B,QAAQ,CAAC,YAAY,QAAQ;IAE7B,OAAO,CAAC,gBAAgB,CAAS;IAIjC,OAAO,CAAC,SAAS,CAAuB;IAGxC,OAAO,CAAC,cAAc,CAAS;IAEzB,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAIrC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAO5B;;;;OAIG;IACH,OAAO,CAAC,cAAc;IActB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IA0B3D,qBAAqB,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAStD,iBAAiB,IAAI,MAAM,EAAE;IAK7B,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAyFlC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IAoBlE,YAAY,IAAI,IAAI;IAOpB,yCAAyC;IACzC,UAAU,IAAI,OAAO;IAIrB,oEAAoE;IACpE,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAInC,qDAAqD;IACrD,YAAY,IAAI,MAAM,GAAG,IAAI;CAG9B"}

package/dist/adapters/claude.js

@@ -0,0 +1,201 @@
+import { randomUUID } from 'crypto';
+import { runCommand, commandExists } from '../utils.js';
+/**
+ * Adapter for Claude Code CLI
+ *
+ * Claude Code supports:
+ * - Non-interactive mode via -p/--print flag
+ * - Output formats: text, json, stream-json
+ * - Session continuation via --session-id (isolated from other sessions in same directory)
+ */
+export class ClaudeAdapter {
+    name = 'claude';
+    displayName = 'Claude Code';
+    color = '\x1b[96m'; // brightCyan
+    // Claude shows ❯ character when ready for input (with possible trailing chars like tool name)
+    // Match: ❯ followed by optional text and arrow or end of string/line
+    promptPattern = /❯\s*(\w*\s*→)?.*$/m;
+    // Fallback: if no output for 3 seconds, assume response complete
+    // Claude Code can have brief pauses between output chunks during response generation
+    idleTimeout = 3000;
+    // Claude starts relatively quickly (~2.5 seconds for first launch)
+    startupDelay = 2500;
+    hasActiveSession = false;
+    // Unique session ID for aic's Claude sessions - prevents collision with
+    // other Claude Code sessions running in the same directory
+    sessionId = null;
+    // Track if we've used the session ID at least once (to know whether to use --session-id or --resume)
+    sessionCreated = false;
+    async isAvailable() {
+        return commandExists('claude');
+    }
+    /**
+     * Get or create a unique session ID for aic's Claude sessions.
+     * This isolates aic from other Claude Code sessions in the same directory.
+     */
+    getOrCreateSessionId() {
+        if (!this.sessionId) {
+            this.sessionId = randomUUID();
+        }
+        return this.sessionId;
+    }
+    /**
+     * Get session args for Claude commands.
+     * First call uses --session-id to CREATE the session.
+     * Subsequent calls use --resume to CONTINUE the session (avoids "already in use" errors).
+     */
+    getSessionArgs() {
+        const sessionId = this.getOrCreateSessionId();
+        if (!this.sessionCreated) {
+            // First call - create the session with this ID
+            // Mark as created immediately so subsequent calls use --resume
+            // (even if this command fails, the session ID is reserved)
+            this.sessionCreated = true;
+            return ['--session-id', sessionId];
+        }
+        else {
+            // Subsequent calls - resume the existing session
+            return ['--resume', sessionId];
+        }
+    }
+    getCommand(prompt, options) {
+        // For slash commands, run without -p to access Claude's internal commands
+        const isSlashCommand = prompt.startsWith('/');
+        const args = [];
+        if (!isSlashCommand) {
+            args.push('-p'); // Print mode for regular prompts
+            // Note: We intentionally don't enable --tools or --permission-mode here
+            // This makes print mode read-only (no file edits without user consent)
+            // Use /i (interactive mode) for full tool access with approvals
+        }
+        // Use session args to isolate and continue aic's sessions
+        if (options?.continueSession !== false) {
+            args.push(...this.getSessionArgs());
+        }
+        // Add the prompt as the last argument (only for non-slash commands in print mode)
+        if (!isSlashCommand) {
+            args.push(prompt);
+        }
+        return ['claude', ...args];
+    }
+    getInteractiveCommand(options) {
+        const args = [];
+        // Use session args to maintain isolated session
+        if (options?.continueSession !== false) {
+            args.push(...this.getSessionArgs());
+        }
+        return ['claude', ...args];
+    }
+    getPersistentArgs() {
+        // Use session args for PTY - will create or resume as appropriate
+        return this.getSessionArgs();
+    }
+    cleanResponse(rawOutput) {
+        let output = rawOutput;
+        // Remove all ANSI escape sequences first
+        output = output.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+        output = output.replace(/\x1b\[\??\d+[hl]/g, '');
+        output = output.replace(/\x1b\[\d* ?q/g, '');
+        output = output.replace(/\x1b\][^\x07]*\x07/g, ''); // OSC sequences
+        // Remove spinner frames
+        output = output.replace(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/g, '');
+        // Remove box drawing characters
+        output = output.replace(/[╭╮╰╯│─┌┐└┘├┤┬┴┼║═╔╗╚╝╠╣╦╩╬▐▛▜▝▘]/g, '');
+        // Remove common status line patterns (e.g., "Reading file...", "Thinking...")
+        output = output.replace(/^(Reading|Writing|Analyzing|Thinking|Searching|Running).*$/gm, '');
+        // Remove the prompt line itself (❯ followed by tool name → )
+        output = output.replace(/❯\s*[a-z]+\s*→.*$/gm, '');
+        output = output.replace(/❯\s*$/gm, '');
+        // Remove Claude Code UI elements
+        output = output.replace(/^\s*Claude Code v[\d.]+\s*$/gm, '');
+        output = output.replace(/^\s*Opus.*API Usage.*$/gm, '');
+        output = output.replace(/^\s*\/model to try.*$/gm, '');
+        output = output.replace(/^\s*~\/.*$/gm, ''); // Directory paths
+        output = output.replace(/^\s*\?\s*for shortcuts\s*$/gm, '');
+        output = output.replace(/^\s*Try ".*"\s*$/gm, '');
+        // Remove typing hints and keyboard shortcuts help
+        output = output.replace(/You can also use Ctrl\+P.*history.*$/gm, '');
+        output = output.replace(/\(esc to cancel.*\)/g, '');
+        output = output.replace(/^\s*no sandbox.*$/gm, '');
+        output = output.replace(/^\s*auto\s*$/gm, '');
+        // Remove welcome screen elements
+        output = output.replace(/^\s*Welcome back!\s*$/gm, '');
+        output = output.replace(/^\s*Tips for getting started\s*$/gm, '');
+        output = output.replace(/^\s*Run \/init.*$/gm, '');
+        output = output.replace(/^\s*Recent activity\s*$/gm, '');
+        output = output.replace(/^\s*No recent activity\s*$/gm, '');
+        // Remove tool use indicators (⏺ Read, ⏺ Write, etc.) but keep content
+        output = output.replace(/^⏺\s+(Read|Write|Edit|Bash|Glob|Grep)\(.*\)\s*$/gm, '');
+        output = output.replace(/^\s*⎿\s+.*$/gm, ''); // Tool result indicators
+        // Extract response content - Claude responses often start with ⏺
+        const responseBlocks = [];
+        const lines = output.split('\n');
+        let inResponse = false;
+        let currentBlock = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Start of a response block (⏺ without tool name after it)
+            if (trimmed.startsWith('⏺') && !trimmed.match(/^⏺\s+(Read|Write|Edit|Bash|Glob|Grep)/)) {
+                if (currentBlock.length > 0) {
+                    responseBlocks.push(currentBlock.join('\n'));
+                }
+                currentBlock = [trimmed.replace(/^⏺\s*/, '')];
+                inResponse = true;
+            }
+            else if (inResponse && trimmed.length > 0) {
+                // Continue capturing response content
+                if (!trimmed.match(/^[\s│─╭╮╰╯]*$/) && trimmed.length > 2) {
+                    currentBlock.push(line);
+                }
+            }
+            else if (trimmed.length === 0 && inResponse) {
+                currentBlock.push('');
+            }
+        }
+        if (currentBlock.length > 0) {
+            responseBlocks.push(currentBlock.join('\n'));
+        }
+        // If we found response blocks, use those; otherwise use cleaned output
+        if (responseBlocks.length > 0) {
+            output = responseBlocks.join('\n\n');
+        }
+        // Final cleanup
+        output = output.replace(/\n{3,}/g, '\n\n');
+        output = output.replace(/^\s+$/gm, '');
+        return output.trim();
+    }
+    async send(prompt, options) {
+        // For print mode (-p), use non-interactive runCommand to avoid messing with stdin
+        const args = this.getCommand(prompt, options).slice(1); // Remove 'claude' from start
+        const result = await runCommand('claude', args, {
+            cwd: options?.cwd || process.cwd(),
+        });
+        if (result.exitCode !== 0) {
+            const errorMsg = result.stderr.trim() || result.stdout.trim() || 'Unknown error';
+            throw new Error(`Claude Code exited with code ${result.exitCode}: ${errorMsg}`);
+        }
+        // Mark that we now have an active session
+        this.hasActiveSession = true;
+        // Return stdout (already plain text in print mode)
+        return result.stdout.trim();
+    }
+    resetContext() {
+        this.hasActiveSession = false;
+        // Generate a new session ID on reset to start fresh
+        this.sessionId = null;
+        this.sessionCreated = false;
+    }
+    /** Check if there's an active session */
+    hasSession() {
+        return this.hasActiveSession;
+    }
+    /** Mark that a session exists (for loading from persisted state) */
+    setHasSession(value) {
+        this.hasActiveSession = value;
+    }
+    /** Get current session ID (for debugging/logging) */
+    getSessionId() {
+        return this.sessionId;
+    }
+}
+//# sourceMappingURL=claude.js.map