code-squad-cli 1.2.6 → 1.2.9

package/dist/flip/constants/filters.d.ts

@@ -0,0 +1,2 @@
+export declare const FILTERED_PATTERNS: Set<string>;
+export declare function isFiltered(name: string): boolean;

package/dist/flip/constants/filters.js

@@ -0,0 +1,30 @@
+// Patterns to filter for performance (O(1) lookup with Set)
+// These are system directories that users don't directly edit
+export const FILTERED_PATTERNS = new Set([
+    // Package managers
+    'node_modules',
+    'vendor',
+    '.pnpm-store',
+    // VCS internal
+    '.git',
+    '.svn',
+    '.hg',
+    // OS metadata
+    '.DS_Store',
+    'Thumbs.db',
+    // Build output
+    'dist',
+    'build',
+    'out',
+    // Cache directories
+    '.cache',
+    '.next',
+    '.nuxt',
+    'coverage',
+    '__pycache__',
+    '.pytest_cache',
+    'target',
+]);
+export function isFiltered(name) {
+    return FILTERED_PATTERNS.has(name);
+}

package/dist/flip/events/SSEManager.d.ts

@@ -0,0 +1,10 @@
+import { Response } from 'express';
+import { SyncEvent } from './types.js';
+export declare class SSEManager {
+    private clients;
+    addClient(res: Response): void;
+    removeClient(res: Response): void;
+    broadcast(event: SyncEvent): void;
+    closeAll(): void;
+    get clientCount(): number;
+}

package/dist/flip/events/SSEManager.js

@@ -0,0 +1,28 @@
+export class SSEManager {
+    clients = new Set();
+    addClient(res) {
+        this.clients.add(res);
+        res.on('close', () => {
+            this.clients.delete(res);
+        });
+    }
+    removeClient(res) {
+        this.clients.delete(res);
+    }
+    broadcast(event) {
+        const data = JSON.stringify(event);
+        const message = `data: ${data}\n\n`;
+        this.clients.forEach(client => {
+            client.write(message);
+        });
+    }
+    closeAll() {
+        this.clients.forEach(client => {
+            client.end();
+        });
+        this.clients.clear();
+    }
+    get clientCount() {
+        return this.clients.size;
+    }
+}

package/dist/flip/events/types.d.ts

@@ -0,0 +1,11 @@
+export type FilesChangeEvent = {
+    type: 'files-changed';
+};
+export type FileContentEvent = {
+    type: 'file-changed';
+    path: string;
+};
+export type GitChangeEvent = {
+    type: 'git-changed';
+};
+export type SyncEvent = FilesChangeEvent | FileContentEvent | GitChangeEvent;

package/dist/flip/events/types.js

@@ -0,0 +1 @@
+export {};

package/dist/flip/index.js

@@ -5,7 +5,7 @@ import fs from 'fs';
 import os from 'os';
 import { execSync } from 'child_process';
 import { confirm } from '@inquirer/prompts';
-import clipboardy from 'clipboardy';
+import { copyToClipboard } from './output/clipboard.js';
 const DEFAULT_PORT = 51234;
 function formatTime() {
     const now = new Date();
@@ -226,7 +226,7 @@ osascript ${applescriptPath} > /dev/null 2>&1
     console.log('└─────────────────────────────────────────────────┘');
     console.log('');
     // Copy path to clipboard
-    await clipboardy.write(shPath);
+    await copyToClipboard(shPath);
     console.log(`✓ Copied to clipboard: ${shPath}`);
     console.log('');
     await confirm({

package/dist/flip/output/autopaste.js

@@ -1,4 +1,4 @@
-import { execSync } from 'child_process';
+import { spawn } from 'child_process';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
@@ -70,9 +70,21 @@ async function pasteToOriginalSession(sessionId) {
         `;
     }
     try {
-        execSync(`osascript -e '${script.replace(/'/g, "'\"'\"'")}'`, {
-            stdio: 'pipe',
+        // Write script to temp file and execute via detached process
+        const tmpScript = path.join(os.tmpdir(), `flip-paste-${Date.now()}.scpt`);
+        fs.writeFileSync(tmpScript, script);
+        const child = spawn('osascript', [tmpScript], {
+            detached: true,
+            stdio: 'ignore',
         });
+        child.unref();
+        // Schedule cleanup
+        setTimeout(() => {
+            try {
+                fs.unlinkSync(tmpScript);
+            }
+            catch { }
+        }, 5000);
     }
     catch (e) {
         console.error('Failed to paste to iTerm:', e);

package/dist/flip/output/clipboard.js

@@ -1,7 +1,61 @@
-import clipboardy from 'clipboardy';
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
 /**
  * Copy text to system clipboard
  */
 export async function copyToClipboard(text) {
-    await clipboardy.write(text);
+    if (process.platform === 'darwin') {
+        // Write to temp file first, then use pbcopy via shell
+        const tmpFile = path.join(os.tmpdir(), `flip-clipboard-${Date.now()}.txt`);
+        try {
+            fs.writeFileSync(tmpFile, text);
+            // Use a detached process to avoid EBADF
+            const child = spawn('sh', ['-c', `cat "${tmpFile}" | pbcopy && rm "${tmpFile}"`], {
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.unref();
+        }
+        catch (e) {
+            // Fallback: just leave the file for manual copy
+            console.log(`Output saved to: ${tmpFile}`);
+            throw e;
+        }
+    }
+    else if (process.platform === 'linux') {
+        const tmpFile = path.join(os.tmpdir(), `flip-clipboard-${Date.now()}.txt`);
+        fs.writeFileSync(tmpFile, text);
+        try {
+            const child = spawn('sh', ['-c', `cat "${tmpFile}" | xclip -selection clipboard && rm "${tmpFile}"`], {
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.unref();
+        }
+        catch {
+            try {
+                const child = spawn('sh', ['-c', `cat "${tmpFile}" | xsel --clipboard --input && rm "${tmpFile}"`], {
+                    detached: true,
+                    stdio: 'ignore',
+                });
+                child.unref();
+            }
+            catch (e) {
+                // Final fallback if both xclip and xsel fail
+                console.log(`Output saved to: ${tmpFile}`);
+                throw e;
+            }
+        }
+    }
+    else if (process.platform === 'win32') {
+        const tmpFile = path.join(os.tmpdir(), `flip-clipboard-${Date.now()}.txt`);
+        fs.writeFileSync(tmpFile, text);
+        const child = spawn('cmd', ['/c', `type "${tmpFile}" | clip && del "${tmpFile}"`], {
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.unref();
+    }
 }

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

@@ -0,0 +1,3 @@
+import type { Router as IRouter } from 'express';
+import { SSEManager } from '../events/SSEManager.js';
+export declare function createEventsRouter(sseManager: SSEManager): IRouter;

package/dist/flip/routes/events.js

@@ -0,0 +1,25 @@
+import { Router } from 'express';
+export function createEventsRouter(sseManager) {
+    const router = Router();
+    // GET /api/events - SSE endpoint for real-time updates
+    router.get('/', (req, res) => {
+        // Set SSE headers
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        res.setHeader('X-Accel-Buffering', 'no'); // Disable nginx buffering
+        // Send initial connection message
+        res.write('data: {"type":"connected"}\n\n');
+        // Register client
+        sseManager.addClient(res);
+        // Keep connection alive with heartbeat
+        const heartbeat = setInterval(() => {
+            res.write(':heartbeat\n\n');
+        }, 30000);
+        // Cleanup on close (removeClient is handled by SSEManager)
+        req.on('close', () => {
+            clearInterval(heartbeat);
+        });
+    });
+    return router;
+}

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

@@ -3,14 +3,21 @@ export interface FileNode {
     path: string;
     name: string;
     type: 'file' | 'directory';
+    filtered?: boolean;
     children?: FileNode[];
 }
 export interface FilesResponse {
     root: string;
     tree: FileNode[];
 }
+export interface FileWithMtime {
+    path: string;
+    mtime: number;
+}
 export interface FlatFilesResponse {
-    files: string[];
+    files: FileWithMtime[];
+    filteredDirs: string[];
+    recentFile: string | null;
 }
 declare const router: IRouter;
 export { router as filesRouter };

package/dist/flip/routes/files.js

@@ -1,62 +1,8 @@
 import { Router } from 'express';
 import fs from 'fs';
 import path from 'path';
+import { isFiltered } from '../constants/filters.js';
 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',
-];
-// Dotfiles that should be visible in the file tree
-const VISIBLE_DOTFILES = new Set([
-    '.gitignore',
-    '.gitattributes',
-    '.env.example',
-    '.env.local.example',
-    '.eslintrc',
-    '.eslintrc.js',
-    '.eslintrc.cjs',
-    '.eslintrc.json',
-    '.eslintrc.yml',
-    '.prettierrc',
-    '.prettierrc.js',
-    '.prettierrc.cjs',
-    '.prettierrc.json',
-    '.prettierrc.yml',
-    '.editorconfig',
-    '.npmrc',
-    '.nvmrc',
-    '.node-version',
-    '.dockerignore',
-    '.browserslistrc',
-    '.babelrc',
-    '.babelrc.js',
-    '.babelrc.json',
-]);
-function shouldIgnore(name) {
-    if (name.startsWith('.')) {
-        // Allow specific dotfiles
-        return !VISIBLE_DOTFILES.has(name);
-    }
-    return DEFAULT_IGNORES.includes(name);
-}
 function buildFileTree(rootPath, currentPath, maxDepth, depth = 0) {
     if (depth > maxDepth)
         return [];
@@ -71,40 +17,54 @@ function buildFileTree(rootPath, currentPath, maxDepth, depth = 0) {
         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 filtered = isFiltered(entry.name);
         const node = {
             path: relativePath,
             name: entry.name,
             type: entry.isDirectory() ? 'directory' : 'file',
+            ...(filtered && { filtered: true }),
         };
-        if (entry.isDirectory()) {
+        // Don't load children for filtered directories (performance)
+        if (entry.isDirectory() && !filtered) {
             node.children = buildFileTree(rootPath, fullPath, maxDepth, depth + 1);
         }
         nodes.push(node);
     }
     return nodes;
 }
-function collectFlatFiles(rootPath, currentPath, maxDepth, depth = 0) {
+// Memory-efficient: pass result object through recursion to avoid intermediate arrays
+function collectFlatFiles(rootPath, currentPath, maxDepth, depth = 0, result = { files: [], filteredDirs: [] }) {
     if (depth > maxDepth)
-        return [];
+        return result;
     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 (isFiltered(entry.name)) {
+            if (entry.isDirectory()) {
+                result.filteredDirs.push(relativePath);
+            }
+            continue; // Don't traverse filtered directories
+        }
         if (entry.isFile()) {
-            files.push(relativePath);
+            try {
+                const stat = fs.statSync(fullPath);
+                result.files.push({
+                    path: relativePath,
+                    mtime: stat.mtimeMs,
+                });
+            }
+            catch {
+                // Skip files that can't be stat'd
+            }
         }
         else if (entry.isDirectory()) {
-            files.push(...collectFlatFiles(rootPath, fullPath, maxDepth, depth + 1));
+            collectFlatFiles(rootPath, fullPath, maxDepth, depth + 1, result);
         }
     }
-    return files;
+    return result;
 }
 // GET /api/files - Get file tree structure
 router.get('/', (req, res) => {
@@ -116,13 +76,23 @@ router.get('/', (req, res) => {
     };
     res.json(response);
 });
-// GET /api/files/flat - Get flat list of all files
+// GET /api/files/flat - Get flat list of all files with mtime
 router.get('/flat', (req, res) => {
     const state = req.app.locals.state;
-    const files = collectFlatFiles(state.cwd, state.cwd, 10);
-    files.sort();
+    const result = collectFlatFiles(state.cwd, state.cwd, 10);
+    // Sort files by path for consistent display
+    result.files.sort((a, b) => a.path.localeCompare(b.path));
+    result.filteredDirs.sort();
+    // Find the most recently modified file
+    let recentFile = null;
+    if (result.files.length > 0) {
+        const mostRecent = result.files.reduce((prev, curr) => curr.mtime > prev.mtime ? curr : prev);
+        recentFile = mostRecent.path;
+    }
     const response = {
-        files,
+        files: result.files,
+        filteredDirs: result.filteredDirs,
+        recentFile,
     };
     res.json(response);
 });

package/dist/flip/routes/static.js

@@ -8,8 +8,10 @@ export function createStaticRouter() {
     // Get __dirname equivalent in ESM
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = path.dirname(__filename);
-    // Path to the built web-ui (relative to dist/ after bundling)
-    const distPath = path.resolve(__dirname, 'flip-ui/dist');
+    // Path to the built web-ui
+    // In development (tsx): __dirname is src/flip/routes, go up 3 levels to packages/cli
+    // In production (bundled): __dirname is dist/flip/routes, go up 3 levels to packages/cli
+    const distPath = path.resolve(__dirname, '../../../flip-ui/dist');
     // Check if dist exists (for development vs production)
     if (fs.existsSync(distPath)) {
         // Serve static files

package/dist/flip/routes/submit.js

@@ -18,19 +18,26 @@ router.post('/', async (req, res) => {
     }));
     // Format the output
     const formatted = formatComments(comments);
-    // Copy to clipboard
+    // Copy to clipboard and schedule paste only if copy succeeds
+    let clipboardSuccess = false;
     try {
         await copyToClipboard(formatted);
+        clipboardSuccess = true;
     }
     catch (e) {
         console.error('Failed to copy to clipboard:', e);
+        console.log('\n--- Output (copy manually) ---');
+        console.log(formatted);
+        console.log('--- End of output ---\n');
     }
-    // Schedule paste (will execute after server shuts down)
-    try {
-        await schedulePaste(body.session_id);
-    }
-    catch (e) {
-        console.error('Failed to schedule paste:', e);
+    // Schedule paste only if clipboard copy succeeded
+    if (clipboardSuccess) {
+        try {
+            await schedulePaste(body.session_id);
+        }
+        catch (e) {
+            console.error('Failed to schedule paste:', e);
+        }
     }
     // Send response before shutdown
     res.json({ status: 'ok' });

package/dist/flip/server/Server.d.ts

@@ -1,6 +1,6 @@
 export interface AppState {
     cwd: string;
-    resolve: ((output: string | null) => void) | null;
+    resolve: ((output: string | null) => void | Promise<void>) | null;
 }
 export declare class Server {
     private cwd;

package/dist/flip/server/Server.js

@@ -8,6 +8,9 @@ import { gitRouter } from '../routes/git.js';
 import { submitRouter } from '../routes/submit.js';
 import { cancelRouter } from '../routes/cancel.js';
 import { createStaticRouter } from '../routes/static.js';
+import { createEventsRouter } from '../routes/events.js';
+import { FileWatcher } from '../watcher/FileWatcher.js';
+import { SSEManager } from '../events/SSEManager.js';
 export class Server {
     cwd;
     port;
@@ -27,18 +30,37 @@ export class Server {
             app.use(express.json());
             // Store state in app locals
             app.locals.state = state;
+            // Initialize SSE manager and file watcher
+            const sseManager = new SSEManager();
+            const fileWatcher = new FileWatcher({ cwd: this.cwd });
+            // Set up watcher event handlers
+            fileWatcher.onFilesChanged(() => {
+                sseManager.broadcast({ type: 'files-changed' });
+            });
+            fileWatcher.onFileChanged((path) => {
+                sseManager.broadcast({ type: 'file-changed', path });
+            });
+            fileWatcher.onGitChanged(() => {
+                sseManager.broadcast({ type: 'git-changed' });
+            });
+            // Start watching
+            fileWatcher.start();
             // API routes
             app.use('/api/files', filesRouter);
             app.use('/api/file', fileRouter);
             app.use('/api/git', gitRouter);
             app.use('/api/submit', submitRouter);
             app.use('/api/cancel', cancelRouter);
+            app.use('/api/events', createEventsRouter(sseManager));
             // Static files (fallback to web-ui dist)
             app.use(createStaticRouter());
             const server = http.createServer(app);
             // Set up the shutdown mechanism
-            state.resolve = (output) => {
-                server.close();
+            state.resolve = async (output) => {
+                // Cleanup watcher and SSE connections
+                await fileWatcher.stop();
+                sseManager.closeAll();
+                await new Promise(res => server.close(() => res()));
                 resolve(output);
             };
             server.listen(this.port, '127.0.0.1', () => {

package/dist/flip/watcher/FileWatcher.d.ts

@@ -0,0 +1,29 @@
+export interface FileWatcherOptions {
+    cwd: string;
+    debounceMs?: number;
+}
+type EventCallback = () => void;
+type FileEventCallback = (filePath: string) => void;
+export declare class FileWatcher {
+    private watcher;
+    private cwd;
+    private debounceMs;
+    private filesChangedCallbacks;
+    private fileChangedCallbacks;
+    private gitChangedCallbacks;
+    private filesDebounceTimer;
+    private gitDebounceTimer;
+    private fileDebounceTimers;
+    constructor(options: FileWatcherOptions);
+    start(): void;
+    stop(): Promise<void>;
+    onFilesChanged(callback: EventCallback): void;
+    onFileChanged(callback: FileEventCallback): void;
+    onGitChanged(callback: EventCallback): void;
+    private handleFileEvent;
+    private handleDirEvent;
+    private emitFilesChanged;
+    private emitFileChanged;
+    private emitGitChanged;
+}
+export {};