aniclaude 1.0.0

package/dist/index.js

@@ -0,0 +1,332 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * AniClaude CLI
+ * Voice-enabled Claude Code - talk to Claude in your terminal
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("./config");
+const server_1 = require("./server");
+const pty_1 = require("./pty");
+const child_process_1 = require("child_process");
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Hook script content - reads transcript and sends ALL new assistant text to TTS
+const TTS_HOOK_SCRIPT = `#!/usr/bin/env python3
+import sys
+import json
+import os
+import urllib.request
+
+try:
+    input_data = json.load(sys.stdin)
+    transcript_path = input_data.get('transcript_path', '')
+
+    if not transcript_path:
+        sys.exit(0)
+
+    # State file to track last processed line
+    state_file = transcript_path + '.aniclaude_state'
+    last_line = 0
+    if os.path.exists(state_file):
+        try:
+            with open(state_file, 'r') as f:
+                last_line = int(f.read().strip())
+        except:
+            last_line = 0
+
+    # Read transcript (JSONL format)
+    with open(transcript_path, 'r') as f:
+        lines = f.readlines()
+
+    # Collect all NEW assistant text (since last processed)
+    all_text = []
+    for i, line in enumerate(lines):
+        if i < last_line:
+            continue
+        try:
+            entry = json.loads(line)
+            message = entry.get('message', entry)
+            if message.get('role') == 'assistant':
+                content = message.get('content', [])
+                for block in content:
+                    if isinstance(block, dict) and block.get('type') == 'text':
+                        text = block.get('text', '')
+                        if text and len(text) > 5:
+                            all_text.append(text)
+        except:
+            continue
+
+    # Save state
+    with open(state_file, 'w') as f:
+        f.write(str(len(lines)))
+
+    if not all_text:
+        sys.exit(0)
+
+    # Join all text and send to TTS
+    combined = ' '.join(all_text)
+    if len(combined) < 10:
+        sys.exit(0)
+
+    data = json.dumps({'text': combined}).encode('utf-8')
+    req = urllib.request.Request(
+        'http://localhost:${config_1.HTTP_PORT}/relay',
+        data=data,
+        headers={'Content-Type': 'application/json'}
+    )
+    urllib.request.urlopen(req, timeout=5)
+except Exception as e:
+    # Uncomment for debugging:
+    # print(f"Hook error: {e}", file=sys.stderr)
+    pass
+
+sys.exit(0)
+`;
+/**
+ * Set up the TTS hook in Claude settings
+ */
+function setupTTSHook() {
+    const homeDir = os.homedir();
+    const claudeDir = path.join(homeDir, '.claude');
+    const hooksDir = path.join(claudeDir, 'hooks');
+    const settingsPath = path.join(claudeDir, 'settings.json');
+    const hookScriptPath = path.join(hooksDir, 'aniclaude-tts.py');
+    // Create hooks directory if needed
+    if (!fs.existsSync(hooksDir)) {
+        fs.mkdirSync(hooksDir, { recursive: true });
+    }
+    // Write hook script
+    fs.writeFileSync(hookScriptPath, TTS_HOOK_SCRIPT.replace('${HTTP_PORT}', String(config_1.HTTP_PORT)));
+    fs.chmodSync(hookScriptPath, '755');
+    // Update settings.json
+    let settings = {};
+    if (fs.existsSync(settingsPath)) {
+        try {
+            settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+        }
+        catch {
+            settings = {};
+        }
+    }
+    // Add our hook to Stop hooks
+    const hooks = settings.hooks || {};
+    const stopHooks = hooks.Stop || [];
+    // Check if our hook already exists
+    const hookExists = stopHooks.some((h) => {
+        const hook = h;
+        const innerHooks = hook.hooks;
+        return innerHooks?.some((ih) => typeof ih.command === 'string' && ih.command.includes('aniclaude-tts.py'));
+    });
+    if (!hookExists) {
+        stopHooks.push({
+            matcher: '',
+            hooks: [
+                {
+                    type: 'command',
+                    command: hookScriptPath
+                }
+            ]
+        });
+        hooks.Stop = stopHooks;
+        settings.hooks = hooks;
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+        console.log('[AniClaude] TTS hook configured');
+    }
+}
+// Parse command line arguments
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let skipPermissions = true; // Default to skipping permissions
+    let noBrowser = false;
+    const claudeArgs = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--help' || arg === '-h') {
+            showHelp();
+            process.exit(0);
+        }
+        else if (arg === '--with-permissions') {
+            skipPermissions = false;
+        }
+        else if (arg === '--no-browser') {
+            noBrowser = true;
+        }
+        else if (arg === '--version' || arg === '-v') {
+            console.log('aniclaude v1.0.0');
+            process.exit(0);
+        }
+        else {
+            claudeArgs.push(arg);
+        }
+    }
+    return { skipPermissions, noBrowser, claudeArgs };
+}
+function showHelp() {
+    console.log(`
+\x1b[36mAniClaude\x1b[0m - Voice-enabled Claude Code
+
+\x1b[33mUsage:\x1b[0m
+  npx aniclaude [options]
+
+\x1b[33mOptions:\x1b[0m
+  --with-permissions    Run Claude with permission prompts (default: skipped)
+  --no-browser          Don't open the avatar window
+  -h, --help            Show this help
+  -v, --version         Show version
+
+\x1b[33mExamples:\x1b[0m
+  npx aniclaude                  Start with defaults (no permission prompts)
+  npx aniclaude --no-browser     CLI only, no avatar window
+`);
+}
+/**
+ * Open the avatar window in a small popup
+ */
+function openAvatarWindow(url) {
+    const platform = os.platform();
+    if (platform === 'darwin') {
+        // macOS: Use AppleScript to open Chrome with specific size
+        const chromeScript = `
+      tell application "Google Chrome"
+        set newWindow to make new window
+        set bounds of newWindow to {100, 100, ${100 + config_1.WINDOW_WIDTH}, ${100 + config_1.WINDOW_HEIGHT}}
+        set URL of active tab of newWindow to "${url}"
+      end tell
+    `;
+        try {
+            (0, child_process_1.execSync)(`osascript -e '${chromeScript}'`, { stdio: 'ignore' });
+            return;
+        }
+        catch {
+            // Chrome not available, try Safari
+        }
+        const safariScript = `
+      tell application "Safari"
+        make new document with properties {URL:"${url}"}
+        set bounds of front window to {100, 100, ${100 + config_1.WINDOW_WIDTH}, ${100 + config_1.WINDOW_HEIGHT}}
+      end tell
+    `;
+        try {
+            (0, child_process_1.execSync)(`osascript -e '${safariScript}'`, { stdio: 'ignore' });
+            return;
+        }
+        catch {
+            // Safari not available
+        }
+    }
+    // Fallback: use open module
+    Promise.resolve().then(() => __importStar(require('open'))).then(({ default: open }) => {
+        open(url);
+    }).catch(() => {
+        console.log(`[AniClaude] Open this URL in your browser: ${url}`);
+    });
+}
+/**
+ * Main entry point
+ */
+async function main() {
+    const { skipPermissions, noBrowser, claudeArgs } = parseArgs();
+    // Show banner
+    console.log(config_1.BANNER);
+    console.log(`\x1b[33mTTS Server:\x1b[0m ${config_1.TTS_SERVER_URL}`);
+    console.log(`\x1b[33mLocal HTTP:\x1b[0m http://localhost:${config_1.HTTP_PORT}`);
+    console.log(`\x1b[33mWebSocket:\x1b[0m  ws://localhost:${config_1.WS_PORT}`);
+    console.log();
+    // Set up TTS hook in Claude settings
+    setupTTSHook();
+    // Start local servers
+    (0, server_1.startHTTPServer)();
+    // Create PTY manager
+    const claudePty = new pty_1.ClaudePTY({
+        skipPermissions,
+        claudeArgs,
+    });
+    // Start WebSocket server with voice input handler
+    (0, server_1.startWebSocketServer)((text) => {
+        claudePty.writeText(text);
+    });
+    // Open avatar window
+    if (!noBrowser) {
+        const url = (0, server_1.getAvatarWindowURL)();
+        console.log('[AniClaude] Opening avatar window...');
+        openAvatarWindow(url);
+    }
+    // Small delay for servers to start
+    await new Promise(resolve => setTimeout(resolve, 500));
+    // Spawn Claude
+    console.log('[AniClaude] Starting Claude Code...');
+    console.log();
+    // Suppress logging to avoid TUI glitches
+    (0, server_1.suppressLogging)();
+    const ptyProcess = claudePty.spawn();
+    // Pipe PTY output to stdout
+    ptyProcess.onData((data) => {
+        process.stdout.write(data);
+    });
+    // Pipe stdin to PTY
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    process.stdin.on('data', (data) => {
+        claudePty.write(data.toString());
+    });
+    // Handle terminal resize
+    process.stdout.on('resize', () => {
+        claudePty.resize(process.stdout.columns || 80, process.stdout.rows || 24);
+    });
+    // Handle PTY exit
+    ptyProcess.onExit(({ exitCode }) => {
+        console.log(`\n[AniClaude] Session ended (exit code: ${exitCode})`);
+        process.exit(exitCode);
+    });
+    // Handle process signals
+    process.on('SIGINT', () => {
+        // Send Ctrl+C to Claude
+        claudePty.write('\x03');
+    });
+    process.on('SIGTERM', () => {
+        claudePty.kill();
+        process.exit(0);
+    });
+}
+// Run
+main().catch((error) => {
+    console.error('\x1b[31m[AniClaude] Error:\x1b[0m', error.message);
+    process.exit(1);
+});

package/dist/pty.d.ts

@@ -0,0 +1,38 @@
+/**
+ * AniClaude PTY Manager
+ * Handles spawning Claude Code with proper TTY support
+ */
+import { IPty } from 'node-pty';
+export declare class ClaudePTY {
+    private pty;
+    private skipPermissions;
+    private claudeArgs;
+    constructor(options?: {
+        skipPermissions?: boolean;
+        claudeArgs?: string[];
+    });
+    /**
+     * Find the claude binary path
+     */
+    private findClaudePath;
+    /**
+     * Spawn Claude Code process
+     */
+    spawn(): IPty;
+    /**
+     * Write text to Claude (with bracketed paste mode)
+     */
+    writeText(text: string): void;
+    /**
+     * Write raw data to Claude
+     */
+    write(data: string): void;
+    /**
+     * Resize the PTY
+     */
+    resize(cols: number, rows: number): void;
+    /**
+     * Kill the PTY process
+     */
+    kill(): void;
+}

package/dist/pty.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * AniClaude PTY Manager
+ * Handles spawning Claude Code with proper TTY support
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudePTY = void 0;
+const pty = __importStar(require("node-pty"));
+const child_process_1 = require("child_process");
+class ClaudePTY {
+    pty = null;
+    skipPermissions;
+    claudeArgs;
+    constructor(options = {}) {
+        this.skipPermissions = options.skipPermissions || false;
+        this.claudeArgs = options.claudeArgs || [];
+    }
+    /**
+     * Find the claude binary path
+     */
+    findClaudePath() {
+        try {
+            // Try to find claude in PATH using shell
+            const claudePath = (0, child_process_1.execSync)('which claude', { encoding: 'utf-8' }).trim();
+            if (claudePath)
+                return claudePath;
+        }
+        catch {
+            // Ignore
+        }
+        // Common locations
+        const paths = [
+            `${process.env.HOME}/.nvm/versions/node/v20.19.0/bin/claude`,
+            `${process.env.HOME}/.local/bin/claude`,
+            '/usr/local/bin/claude',
+            '/opt/homebrew/bin/claude',
+        ];
+        for (const p of paths) {
+            try {
+                (0, child_process_1.execSync)(`test -x "${p}"`, { stdio: 'ignore' });
+                return p;
+            }
+            catch {
+                // Not found, continue
+            }
+        }
+        return 'claude'; // Fall back to PATH
+    }
+    /**
+     * Spawn Claude Code process
+     */
+    spawn() {
+        const args = [];
+        if (this.skipPermissions) {
+            args.push('--dangerously-skip-permissions');
+        }
+        args.push(...this.claudeArgs);
+        // Get terminal size
+        const cols = process.stdout.columns || 80;
+        const rows = process.stdout.rows || 24;
+        // Find claude binary
+        const claudePath = this.findClaudePath();
+        // Spawn through shell since claude is a Node script
+        const shell = process.env.SHELL || '/bin/bash';
+        const shellArgs = ['-c', `"${claudePath}" ${args.map(a => `"${a}"`).join(' ')}`];
+        this.pty = pty.spawn(shell, shellArgs, {
+            name: 'xterm-256color',
+            cols,
+            rows,
+            cwd: process.cwd(),
+            env: {
+                ...process.env,
+                TERM: process.env.TERM || 'xterm-256color',
+            },
+        });
+        return this.pty;
+    }
+    /**
+     * Write text to Claude (with bracketed paste mode)
+     */
+    writeText(text) {
+        if (!this.pty)
+            return;
+        // Use bracketed paste mode to prevent TUI glitches
+        const pasteStart = '\x1b[200~';
+        const pasteEnd = '\x1b[201~';
+        this.pty.write(pasteStart + text + pasteEnd);
+        // Small delay then send Enter
+        setTimeout(() => {
+            this.pty?.write('\r');
+        }, 50);
+    }
+    /**
+     * Write raw data to Claude
+     */
+    write(data) {
+        this.pty?.write(data);
+    }
+    /**
+     * Resize the PTY
+     */
+    resize(cols, rows) {
+        this.pty?.resize(cols, rows);
+    }
+    /**
+     * Kill the PTY process
+     */
+    kill() {
+        this.pty?.kill();
+        this.pty = null;
+    }
+}
+exports.ClaudePTY = ClaudePTY;

package/dist/server.d.ts

@@ -0,0 +1,23 @@
+/**
+ * AniClaude Local Servers
+ * - HTTP server: serves the avatar window HTML and assets
+ * - WebSocket server: relays messages between browser and Claude PTY
+ */
+import http from 'http';
+import { WebSocketServer } from 'ws';
+/**
+ * Suppress logging (call after Claude starts to avoid TUI glitches)
+ */
+export declare function suppressLogging(): void;
+/**
+ * Start HTTP server for serving static files
+ */
+export declare function startHTTPServer(): http.Server;
+/**
+ * Start WebSocket server for browser relay
+ */
+export declare function startWebSocketServer(onVoiceInput: (text: string) => void): WebSocketServer;
+/**
+ * Get the URL for the avatar window
+ */
+export declare function getAvatarWindowURL(): string;