code-squad-cli 1.0.8 → 1.1.1

package/dist/flip/index.d.ts

@@ -0,0 +1 @@
+export declare function runFlip(args: string[]): Promise<void>;

package/dist/flip/index.js

@@ -0,0 +1,246 @@
+import { Server, findFreePort } from './server/Server.js';
+import open from 'open';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { execSync } from 'child_process';
+import { confirm } from '@inquirer/prompts';
+import clipboardy from 'clipboardy';
+const DEFAULT_PORT = 51234;
+function formatTime() {
+    const now = new Date();
+    const hours = String(now.getHours()).padStart(2, '0');
+    const mins = String(now.getMinutes()).padStart(2, '0');
+    const secs = String(now.getSeconds()).padStart(2, '0');
+    return `${hours}:${mins}:${secs}`;
+}
+export async function runFlip(args) {
+    // Parse --session flag from anywhere in args
+    let sessionId;
+    const sessionIdx = args.indexOf('--session');
+    if (sessionIdx !== -1 && args[sessionIdx + 1]) {
+        sessionId = args[sessionIdx + 1];
+    }
+    // Filter out --session and its value for further parsing
+    const filteredArgs = args.filter((arg, idx) => {
+        if (arg === '--session')
+            return false;
+        if (idx > 0 && args[idx - 1] === '--session')
+            return false;
+        return true;
+    });
+    // Parse subcommand
+    let command;
+    let pathArg;
+    if (filteredArgs.length > 0) {
+        switch (filteredArgs[0]) {
+            case 'serve':
+                command = 'serve';
+                pathArg = filteredArgs[1];
+                break;
+            case 'open':
+                command = 'open';
+                break;
+            case 'setup':
+                command = 'setup';
+                break;
+            case '--help':
+            case '-h':
+                printUsage();
+                return;
+            default:
+                command = 'oneshot';
+                pathArg = filteredArgs[0];
+                break;
+        }
+    }
+    else {
+        command = 'oneshot';
+    }
+    const cwd = pathArg ? path.resolve(pathArg) : process.cwd();
+    switch (command) {
+        case 'setup': {
+            await setupHotkey();
+            return;
+        }
+        case 'serve': {
+            // Daemon mode: start server, keep running
+            const port = await findFreePort(DEFAULT_PORT);
+            console.log(`Server running at http://localhost:${port}`);
+            console.log('Press Ctrl+C to stop');
+            console.log('');
+            console.log('To open browser, run: csq flip open');
+            console.log(`Or use hotkey to open: open http://localhost:${port}`);
+            // Run server in loop (restarts after each submit/cancel)
+            while (true) {
+                const server = new Server(cwd, port);
+                const result = await server.run();
+                if (result) {
+                    console.log(`[${formatTime()}] Submitted ${result.length} characters`);
+                }
+                else {
+                    console.log(`[${formatTime()}] Cancelled`);
+                }
+                console.log(`[${formatTime()}] Ready for next session...`);
+            }
+        }
+        case 'open': {
+            // Just open browser to existing server
+            const url = `http://localhost:${DEFAULT_PORT}`;
+            console.log(`Opening ${url} in browser...`);
+            try {
+                await open(url);
+            }
+            catch (e) {
+                console.error('Failed to open browser:', e);
+                console.error('Is the server running? Start with: csq flip serve');
+            }
+            break;
+        }
+        case 'oneshot':
+        default: {
+            // Original behavior: start server, open browser, exit after submit/cancel
+            const port = await findFreePort(DEFAULT_PORT);
+            const url = sessionId
+                ? `http://localhost:${port}?session=${sessionId}`
+                : `http://localhost:${port}`;
+            console.log(`Opening ${url} in browser...`);
+            try {
+                await open(url);
+            }
+            catch (e) {
+                console.error('Failed to open browser:', e);
+                console.log(`Please open ${url} manually`);
+            }
+            const server = new Server(cwd, port);
+            const result = await server.run();
+            if (result) {
+                console.log(`\nSubmitted ${result.length} characters`);
+            }
+            else {
+                console.log('\nCancelled');
+            }
+            break;
+        }
+    }
+}
+function printUsage() {
+    console.error('Usage: csq flip [command] [options]');
+    console.error('');
+    console.error('Commands:');
+    console.error('  serve [path]    Start server in daemon mode (keeps running)');
+    console.error('  open            Open browser to existing server');
+    console.error('  setup           Setup iTerm2 hotkey');
+    console.error('  (no command)    Start server + open browser (one-shot mode)');
+    console.error('');
+    console.error('Options:');
+    console.error('  path               Directory to serve (default: current directory)');
+    console.error('  --session <uuid>   Session ID for paste-back tracking');
+}
+async function setupHotkey() {
+    const configDir = path.join(os.homedir(), '.config', 'flip');
+    const applescriptPath = path.join(configDir, 'flip.applescript');
+    const shPath = path.join(configDir, 'flip.sh');
+    // Get node path
+    let nodePath;
+    try {
+        nodePath = execSync('which node', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        nodePath = '/usr/local/bin/node';
+    }
+    // Get csq path (this script's location)
+    const csqPath = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../index.js');
+    // Create config directory
+    fs.mkdirSync(configDir, { recursive: true });
+    // Write AppleScript
+    const applescriptContent = `#!/usr/bin/osascript
+
+-- flip hotkey script
+-- Generated by: csq flip setup
+
+tell application "iTerm2"
+    tell current session of current window
+        set originalSessionId to id
+        set sessionUUID to do shell script "uuidgen"
+        set currentPath to variable named "path"
+        do shell script "echo '" & originalSessionId & "' > /tmp/flip-view-session-" & sessionUUID
+        do shell script "nohup ${nodePath} ${csqPath} flip --session " & sessionUUID & " " & quoted form of currentPath & " > /tmp/flip.log 2>&1 &"
+    end tell
+end tell
+
+return ""`;
+    fs.writeFileSync(applescriptPath, applescriptContent);
+    fs.chmodSync(applescriptPath, '755');
+    // Write shell wrapper
+    const shContent = `#!/bin/bash
+osascript ${applescriptPath} > /dev/null 2>&1
+`;
+    fs.writeFileSync(shPath, shContent);
+    fs.chmodSync(shPath, '755');
+    console.log('');
+    console.log('┌─────────────────────────────────────────────────┐');
+    console.log('│           Flip Hotkey Setup Wizard              │');
+    console.log('└─────────────────────────────────────────────────┘');
+    console.log('');
+    console.log('✓ Scripts generated:');
+    console.log(`  ${shPath}`);
+    console.log('');
+    // Step 1: Open iTerm2 Settings
+    const openSettings = await confirm({
+        message: 'Open iTerm2 Settings? (Keys → Key Bindings)',
+        default: true,
+    });
+    if (openSettings) {
+        try {
+            execSync(`osascript -e 'tell application "iTerm2" to activate' -e 'tell application "System Events" to keystroke "," using command down'`);
+            console.log('');
+            console.log('  → iTerm2 Settings opened. Navigate to: Keys → Key Bindings');
+        }
+        catch {
+            console.log('  → Could not open settings automatically. Open manually: iTerm2 → Settings → Keys → Key Bindings');
+        }
+    }
+    console.log('');
+    // Step 2: Guide through adding key binding
+    const ready = await confirm({
+        message: 'Ready to add Key Binding? (Click + button in Key Bindings tab)',
+        default: true,
+    });
+    if (!ready) {
+        console.log('');
+        console.log('Run `csq flip setup` again when ready.');
+        return;
+    }
+    console.log('');
+    console.log('┌─────────────────────────────────────────────────┐');
+    console.log('│  Configure the Key Binding:                     │');
+    console.log('├─────────────────────────────────────────────────┤');
+    console.log('│  1. Keyboard Shortcut: Press your hotkey        │');
+    console.log('│     (e.g., ⌘⇧F)                                 │');
+    console.log('│                                                 │');
+    console.log('│  2. Action: Select "Run Coprocess"              │');
+    console.log('│                                                 │');
+    console.log('│  3. Command: Paste the path (copied below)      │');
+    console.log('└─────────────────────────────────────────────────┘');
+    console.log('');
+    // Copy path to clipboard
+    await clipboardy.write(shPath);
+    console.log(`✓ Copied to clipboard: ${shPath}`);
+    console.log('');
+    await confirm({
+        message: 'Done configuring? (Paste the path and click OK)',
+        default: true,
+    });
+    console.log('');
+    console.log('┌─────────────────────────────────────────────────┐');
+    console.log('│  Setup Complete!                                │');
+    console.log('├─────────────────────────────────────────────────┤');
+    console.log('│  Usage:                                         │');
+    console.log('│  1. Focus on any terminal panel                 │');
+    console.log('│  2. Press your hotkey → browser opens           │');
+    console.log('│  3. Select files, add comments                  │');
+    console.log('│  4. Submit → text appears in terminal           │');
+    console.log('└─────────────────────────────────────────────────┘');
+    console.log('');
+}

package/dist/flip/output/autopaste.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Schedule automatic paste to the original iTerm session
+ * @param sessionId The UUID that identifies this flip-view session
+ */
+export declare function schedulePaste(sessionId: string): Promise<void>;

package/dist/flip/output/autopaste.js

@@ -0,0 +1,80 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+/**
+ * Schedule automatic paste to the original iTerm session
+ * @param sessionId The UUID that identifies this flip-view session
+ */
+export async function schedulePaste(sessionId) {
+    if (process.platform !== 'darwin') {
+        console.error('Auto-paste not supported on this platform. Please paste manually (Ctrl+V).');
+        return;
+    }
+    await pasteToOriginalSession(sessionId);
+}
+async function pasteToOriginalSession(sessionId) {
+    // Read the original iTerm session ID from session-specific temp file
+    const sessionFile = path.join(os.tmpdir(), `flip-view-session-${sessionId}`);
+    let itermSessionId;
+    try {
+        itermSessionId = fs.readFileSync(sessionFile, 'utf-8').trim();
+    }
+    catch {
+        // Session file not found
+    }
+    let script;
+    if (itermSessionId) {
+        // Find the original session by ID and paste to it
+        script = `
+            tell application "iTerm2"
+                set found to false
+                repeat with w in windows
+                    repeat with t in tabs of w
+                        repeat with s in sessions of t
+                            if id of s is "${itermSessionId}" then
+                                set found to true
+                                select s
+                                tell s to write text (the clipboard)
+                                tell s to write text ""
+                                return
+                            end if
+                        end repeat
+                    end repeat
+                end repeat
+
+                if not found then
+                    display notification "Original session closed. Output copied to clipboard." with title "flip"
+                end if
+            end tell
+        `;
+        // Cleanup the session file after use
+        try {
+            fs.unlinkSync(sessionFile);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+    else {
+        // Fallback: paste to current iTerm session
+        script = `
+            tell application "iTerm2"
+                activate
+                delay 0.1
+                tell current session of current window
+                    write text (the clipboard)
+                    write text ""
+                end tell
+            end tell
+        `;
+    }
+    try {
+        execSync(`osascript -e '${script.replace(/'/g, "'\"'\"'")}'`, {
+            stdio: 'pipe',
+        });
+    }
+    catch (e) {
+        console.error('Failed to paste to iTerm:', e);
+    }
+}

package/dist/flip/output/clipboard.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Copy text to system clipboard
+ */
+export declare function copyToClipboard(text: string): Promise<void>;

package/dist/flip/output/clipboard.js

@@ -0,0 +1,7 @@
+import clipboardy from 'clipboardy';
+/**
+ * Copy text to system clipboard
+ */
+export async function copyToClipboard(text) {
+    await clipboardy.write(text);
+}

package/dist/flip/output/formatter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Minimal Comment interface compatible with @code-squad/core Comment
+ */
+export interface CommentLike {
+    file: string;
+    line: number;
+    endLine?: number;
+    text: string;
+}
+/**
+ * Format Comment-like entities for AI agent consumption
+ */
+export declare function formatComments(comments: CommentLike[]): string;

package/dist/flip/output/formatter.js

@@ -0,0 +1,18 @@
+/**
+ * Format Comment-like entities for AI agent consumption
+ */
+export function formatComments(comments) {
+    if (comments.length === 0) {
+        return '';
+    }
+    let output = 'The user has annotated the following code locations:\n\n';
+    for (const comment of comments) {
+        const lineRange = comment.endLine && comment.endLine !== comment.line
+            ? `${comment.line}-${comment.endLine}`
+            : `${comment.line}`;
+        const location = `${comment.file}:${lineRange}`;
+        output += `- ${location} -> "${comment.text}"\n`;
+    }
+    output += '\nPlease review these comments and address them.';
+    return output;
+}

package/dist/flip/output/index.d.ts

@@ -0,0 +1,4 @@
+export { formatComments } from './formatter.js';
+export type { CommentLike } from './formatter.js';
+export { copyToClipboard } from './clipboard.js';
+export { schedulePaste } from './autopaste.js';

package/dist/flip/output/index.js

@@ -0,0 +1,3 @@
+export { formatComments } from './formatter.js';
+export { copyToClipboard } from './clipboard.js';
+export { schedulePaste } from './autopaste.js';

package/dist/flip/routes/cancel.d.ts

@@ -0,0 +1,6 @@
+import type { Router as IRouter } from 'express';
+export interface CancelResponse {
+    status: string;
+}
+declare const router: IRouter;
+export { router as cancelRouter };

package/dist/flip/routes/cancel.js

@@ -0,0 +1,13 @@
+import { Router } from 'express';
+const router = Router();
+// POST /api/cancel
+router.post('/', (req, res) => {
+    const state = req.app.locals.state;
+    // Send response before shutdown
+    res.json({ status: 'ok' });
+    // Trigger shutdown without output
+    if (state.resolve) {
+        state.resolve(null);
+    }
+});
+export { router as cancelRouter };

package/dist/flip/routes/file.d.ts

@@ -0,0 +1,8 @@
+import type { Router as IRouter } from 'express';
+export interface FileResponse {
+    path: string;
+    content: string;
+    language: string;
+}
+declare const router: IRouter;
+export { router as fileRouter };

package/dist/flip/routes/file.js

@@ -0,0 +1,77 @@
+import { Router } from 'express';
+import fs from 'fs';
+import path from 'path';
+const router = Router();
+function detectLanguage(filePath) {
+    const ext = path.extname(filePath).slice(1).toLowerCase();
+    const languageMap = {
+        rs: 'rust',
+        js: 'javascript',
+        ts: 'typescript',
+        tsx: 'tsx',
+        jsx: 'jsx',
+        py: 'python',
+        go: 'go',
+        java: 'java',
+        c: 'c',
+        cpp: 'cpp',
+        cc: 'cpp',
+        cxx: 'cpp',
+        h: 'cpp',
+        hpp: 'cpp',
+        md: 'markdown',
+        json: 'json',
+        yaml: 'yaml',
+        yml: 'yaml',
+        toml: 'toml',
+        html: 'html',
+        css: 'css',
+        scss: 'scss',
+        sh: 'bash',
+        bash: 'bash',
+        sql: 'sql',
+        rb: 'ruby',
+        swift: 'swift',
+        kt: 'kotlin',
+        kts: 'kotlin',
+        xml: 'xml',
+        vue: 'vue',
+    };
+    return languageMap[ext] || 'plaintext';
+}
+// GET /api/file?path=<path>
+router.get('/', (req, res) => {
+    const state = req.app.locals.state;
+    const relativePath = req.query.path;
+    if (!relativePath) {
+        res.status(400).json({ error: 'Missing path parameter' });
+        return;
+    }
+    const filePath = path.join(state.cwd, relativePath);
+    // Security check: ensure path is within cwd
+    const resolvedPath = path.resolve(filePath);
+    const resolvedCwd = path.resolve(state.cwd);
+    if (!resolvedPath.startsWith(resolvedCwd)) {
+        res.status(403).json({ error: 'Access denied' });
+        return;
+    }
+    try {
+        const content = fs.readFileSync(resolvedPath, 'utf-8');
+        const language = detectLanguage(relativePath);
+        const response = {
+            path: relativePath,
+            content,
+            language,
+        };
+        res.json(response);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            res.status(404).json({ error: 'File not found' });
+        }
+        else {
+            res.status(500).json({ error: 'Failed to read file' });
+        }
+    }
+});
+export { router as fileRouter };

package/dist/flip/routes/files.d.ts

@@ -0,0 +1,16 @@
+import type { Router as IRouter } from 'express';
+export interface FileNode {
+    path: string;
+    name: string;
+    type: 'file' | 'directory';
+    children?: FileNode[];
+}
+export interface FilesResponse {
+    root: string;
+    tree: FileNode[];
+}
+export interface FlatFilesResponse {
+    files: string[];
+}
+declare const router: IRouter;
+export { router as filesRouter };

package/dist/flip/routes/files.js

@@ -0,0 +1,102 @@
+import { Router } from 'express';
+import fs from 'fs';
+import path from 'path';
+const router = Router();
+// Default ignore patterns (similar to .gitignore behavior)
+const DEFAULT_IGNORES = [
+    'node_modules',
+    '.git',
+    '.svn',
+    '.hg',
+    'dist',
+    'build',
+    'out',
+    '.cache',
+    '.next',
+    '.nuxt',
+    'coverage',
+    '__pycache__',
+    '.pytest_cache',
+    'target',
+    'Cargo.lock',
+    'package-lock.json',
+    'pnpm-lock.yaml',
+    'yarn.lock',
+    '.DS_Store',
+];
+function shouldIgnore(name) {
+    if (name.startsWith('.') && name !== '.gitignore' && name !== '.env.example') {
+        return true;
+    }
+    return DEFAULT_IGNORES.includes(name);
+}
+function buildFileTree(rootPath, currentPath, maxDepth, depth = 0) {
+    if (depth > maxDepth)
+        return [];
+    const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+    const nodes = [];
+    // Sort: directories first, then alphabetically
+    entries.sort((a, b) => {
+        if (a.isDirectory() && !b.isDirectory())
+            return -1;
+        if (!a.isDirectory() && b.isDirectory())
+            return 1;
+        return a.name.localeCompare(b.name);
+    });
+    for (const entry of entries) {
+        if (shouldIgnore(entry.name))
+            continue;
+        const fullPath = path.join(currentPath, entry.name);
+        const relativePath = path.relative(rootPath, fullPath);
+        const node = {
+            path: relativePath,
+            name: entry.name,
+            type: entry.isDirectory() ? 'directory' : 'file',
+        };
+        if (entry.isDirectory()) {
+            node.children = buildFileTree(rootPath, fullPath, maxDepth, depth + 1);
+        }
+        nodes.push(node);
+    }
+    return nodes;
+}
+function collectFlatFiles(rootPath, currentPath, maxDepth, depth = 0) {
+    if (depth > maxDepth)
+        return [];
+    const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        if (shouldIgnore(entry.name))
+            continue;
+        const fullPath = path.join(currentPath, entry.name);
+        const relativePath = path.relative(rootPath, fullPath);
+        if (entry.isFile()) {
+            files.push(relativePath);
+        }
+        else if (entry.isDirectory()) {
+            files.push(...collectFlatFiles(rootPath, fullPath, maxDepth, depth + 1));
+        }
+    }
+    return files;
+}
+// GET /api/files - Get file tree structure
+router.get('/', (req, res) => {
+    const state = req.app.locals.state;
+    const tree = buildFileTree(state.cwd, state.cwd, 10);
+    const response = {
+        root: state.cwd,
+        tree,
+    };
+    res.json(response);
+});
+// GET /api/files/flat - Get flat list of all files
+router.get('/flat', (req, res) => {
+    const state = req.app.locals.state;
+    const files = collectFlatFiles(state.cwd, state.cwd, 10);
+    files.sort();
+    const response = {
+        files,
+    };
+    res.json(response);
+});
+export { router as filesRouter };

package/dist/flip/routes/git.d.ts

@@ -0,0 +1,11 @@
+import type { Router as IRouter } from 'express';
+export interface UnstagedFile {
+    path: string;
+    status: string;
+}
+export interface GitStatusResponse {
+    isGitRepo: boolean;
+    unstaged: UnstagedFile[];
+}
+declare const router: IRouter;
+export { router as gitRouter };