@lovelybunch/api 1.0.7

package/dist/lib/terminal/shell-utils.d.ts

@@ -0,0 +1,33 @@
+export type ShellType = 'bash' | 'zsh' | 'fish' | 'sh' | 'system';
+export interface ShellInfo {
+    name: ShellType;
+    displayName: string;
+    path: string;
+    available: boolean;
+}
+/**
+ * Get the default system shell
+ */
+export declare function getSystemShell(): string;
+/**
+ * Get information about available shells on the system
+ */
+export declare function getAvailableShells(): Promise<ShellInfo[]>;
+/**
+ * Get the shell executable path based on user preference
+ */
+export declare function getShellPath(preference?: ShellType): Promise<string>;
+/**
+ * Get shell arguments for spawning a new shell with an init script
+ */
+export declare function getShellArgs(shellPath: string, initScriptPath: string): string[];
+/**
+ * Prepare shell-specific initialization
+ */
+export declare function prepareShellInit(shellPath: string, initScript: string): {
+    script: string;
+    needsEnvVar?: {
+        name: string;
+        value: string;
+    };
+};

package/dist/lib/terminal/shell-utils.js

@@ -0,0 +1,176 @@
+import { promises as fs } from 'fs';
+import os from 'os';
+/**
+ * Get the default system shell
+ */
+export function getSystemShell() {
+    // Get the user's default shell from environment or passwd
+    const userShell = process.env.SHELL || '/bin/bash';
+    return userShell;
+}
+/**
+ * Check if a shell executable exists and is accessible
+ */
+async function isShellAvailable(shellPath) {
+    try {
+        await fs.access(shellPath, fs.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get information about available shells on the system
+ */
+export async function getAvailableShells() {
+    const shells = [
+        {
+            name: 'bash',
+            displayName: 'Bash',
+            path: '/bin/bash',
+            available: false,
+        },
+        {
+            name: 'zsh',
+            displayName: 'Zsh',
+            path: '/bin/zsh',
+            available: false,
+        },
+        {
+            name: 'fish',
+            displayName: 'Fish',
+            path: '/usr/local/bin/fish',
+            available: false,
+        },
+        {
+            name: 'sh',
+            displayName: 'Sh (Bourne Shell)',
+            path: '/bin/sh',
+            available: false,
+        },
+        {
+            name: 'system',
+            displayName: 'System Default',
+            path: getSystemShell(),
+            available: true,
+        },
+    ];
+    // Check availability of each shell
+    for (const shell of shells) {
+        if (shell.name !== 'system') {
+            shell.available = await isShellAvailable(shell.path);
+            // For fish, also check alternative location
+            if (shell.name === 'fish' && !shell.available) {
+                const altPath = '/opt/homebrew/bin/fish';
+                if (await isShellAvailable(altPath)) {
+                    shell.path = altPath;
+                    shell.available = true;
+                }
+            }
+            // For zsh on macOS, check alternative locations
+            if (shell.name === 'zsh' && !shell.available && os.platform() === 'darwin') {
+                const altPaths = ['/usr/local/bin/zsh', '/opt/homebrew/bin/zsh'];
+                for (const altPath of altPaths) {
+                    if (await isShellAvailable(altPath)) {
+                        shell.path = altPath;
+                        shell.available = true;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    return shells;
+}
+/**
+ * Get the shell executable path based on user preference
+ */
+export async function getShellPath(preference = 'bash') {
+    if (preference === 'system') {
+        return getSystemShell();
+    }
+    const shells = await getAvailableShells();
+    const selectedShell = shells.find(s => s.name === preference);
+    if (selectedShell && selectedShell.available) {
+        return selectedShell.path;
+    }
+    // Fallback to bash if preferred shell is not available
+    const bashShell = shells.find(s => s.name === 'bash');
+    if (bashShell && bashShell.available) {
+        return bashShell.path;
+    }
+    // Ultimate fallback to system shell
+    return getSystemShell();
+}
+/**
+ * Get shell arguments for spawning a new shell with an init script
+ */
+export function getShellArgs(shellPath, initScriptPath) {
+    const shellName = shellPath.split('/').pop() || 'bash';
+    switch (shellName) {
+        case 'bash':
+            return ['--init-file', initScriptPath];
+        case 'zsh':
+            // For zsh, we need to use ZDOTDIR environment variable
+            // The init script will need to be named .zshrc in a temp directory
+            return ['-i'];
+        case 'fish':
+            // Fish uses --init-command
+            return ['--init-command', `source ${initScriptPath}`];
+        case 'sh':
+            // Basic sh doesn't support init files the same way
+            // We'll need to source it manually after start
+            return [];
+        default:
+            // Try bash-style for unknown shells
+            return ['--init-file', initScriptPath];
+    }
+}
+/**
+ * Prepare shell-specific initialization
+ */
+export function prepareShellInit(shellPath, initScript) {
+    const shellName = shellPath.split('/').pop() || 'bash';
+    switch (shellName) {
+        case 'zsh':
+            // For zsh, we need to create a proper .zshrc that sources the system one first
+            // Use proper zsh syntax and prevent content echo
+            // Also fix the prompt to use zsh syntax
+            const zshScript = initScript
+                // Replace bash-style prompt with zsh-style prompt
+                .replace(/export PS1=.*$/m, 'export PROMPT="%F{cyan}[${GAIT_PROPOSAL_ID}]%f %~ %# "');
+            return {
+                script: `#!/bin/zsh
+# GAIT Zsh Initialization
+
+# Source system zshrc if it exists (suppress any output)
+[ -f ~/.zshrc ] && source ~/.zshrc > /dev/null 2>&1 || true
+
+# Custom GAIT initialization
+${zshScript}`,
+                needsEnvVar: { name: 'ZDOTDIR', value: '' } // Will be set to temp dir
+            };
+        case 'fish':
+            // Fish script syntax is different
+            const fishScript = initScript
+                .replace(/export\\s+(\\w+)=(.*)/g, 'set -gx $1 $2')
+                .replace(/alias\\s+(\\w+)=(.*)/g, 'alias $1 $2')
+                // Fish prompt syntax
+                .replace(/export PS1=.*$/m, 'function fish_prompt\n    echo -n (set_color cyan)"[$GAIT_PROPOSAL_ID]"(set_color normal)" "(prompt_pwd)" > "\nend');
+            return {
+                script: fishScript
+            };
+        case 'bash':
+        default:
+            // Bash uses the script with proper PS1 escaping
+            const bashScript = initScript.replace(/export PS1="\[(.*)\] \\w \$ "/, 'export PS1="\\[\\033[36m\\][$GAIT_PROPOSAL_ID]\\[\\033[0m\\] \\w \\$ "');
+            return {
+                script: `# Source system bashrc if it exists
+[ -f ~/.bashrc ] && source ~/.bashrc
+
+# Custom GAIT initialization  
+${bashScript}`
+            };
+    }
+}

package/dist/lib/terminal/terminal-manager.d.ts

@@ -0,0 +1,26 @@
+import { WebSocket } from 'ws';
+import { ShellType } from './shell-utils.js';
+export interface TerminalSession {
+    id: string;
+    proposalId: string;
+    pty: any;
+    websocket?: WebSocket;
+    createdAt: Date;
+    lastActivity: Date;
+    enableLogging?: boolean;
+    logFilePath?: string;
+}
+export declare class TerminalManager {
+    private sessions;
+    private cleanupInterval;
+    constructor();
+    createSession(proposalId: string, enableLogging?: boolean, shellPreference?: ShellType): Promise<TerminalSession>;
+    getSession(sessionId: string): TerminalSession | undefined;
+    getSessionsByProposal(proposalId: string): TerminalSession[];
+    attachWebSocket(sessionId: string, ws: WebSocket): boolean;
+    destroySession(sessionId: string): boolean;
+    resizeSession(sessionId: string, cols: number, rows: number): boolean;
+    private cleanupInactiveSessions;
+    getAllSessions(): TerminalSession[];
+    destroy(): void;
+}

package/dist/lib/terminal/terminal-manager.js

@@ -0,0 +1,276 @@
+import * as pty from 'node-pty';
+import { WebSocket } from 'ws';
+import path from 'path';
+import fs from 'fs';
+import { createInitScript } from './context-helper.js';
+import { getShellPath, getShellArgs, prepareShellInit } from './shell-utils.js';
+export class TerminalManager {
+    sessions = new Map();
+    cleanupInterval;
+    constructor() {
+        // Clean up inactive sessions every 5 minutes
+        this.cleanupInterval = setInterval(() => {
+            this.cleanupInactiveSessions();
+        }, 5 * 60 * 1000);
+    }
+    async createSession(proposalId, enableLogging = false, shellPreference = 'bash') {
+        const sessionId = `${proposalId}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        // Get the project root directory
+        const projectRoot = process.env.GAIT_DATA_PATH ?
+            path.resolve(process.env.GAIT_DATA_PATH) :
+            process.cwd();
+        // Prepare context information
+        const contextInfo = {
+            proposalId,
+            proposalPath: path.join(projectRoot, '.gait', 'proposals', `${proposalId}.md`),
+            contextPath: path.join(projectRoot, '.gait', 'context'),
+            projectRoot,
+        };
+        // Get the shell path based on user preference
+        const shellPath = await getShellPath(shellPreference);
+        const shellName = shellPath.split('/').pop() || 'bash';
+        // Create initialization script
+        const baseInitScript = createInitScript(contextInfo);
+        const { script: initScript, needsEnvVar } = prepareShellInit(shellPath, baseInitScript);
+        // Determine init script path and name based on shell
+        let initScriptPath;
+        let tempDirForZsh;
+        if (shellName === 'zsh' && needsEnvVar) {
+            // For zsh, create a temp directory with .zshrc
+            tempDirForZsh = path.join(projectRoot, '.gait', 'tmp', `zsh-${sessionId}`);
+            fs.mkdirSync(tempDirForZsh, { recursive: true });
+            initScriptPath = path.join(tempDirForZsh, '.zshrc');
+        }
+        else {
+            // For other shells, use regular init script
+            initScriptPath = path.join(projectRoot, '.gait', 'tmp', `init-${sessionId}.sh`);
+            const tmpDir = path.dirname(initScriptPath);
+            fs.mkdirSync(tmpDir, { recursive: true });
+        }
+        try {
+            fs.writeFileSync(initScriptPath, initScript);
+            fs.chmodSync(initScriptPath, '755');
+        }
+        catch (error) {
+            console.error('Error creating init script:', error);
+        }
+        // Set up logging if enabled
+        let logFilePath;
+        if (enableLogging) {
+            const sessionsDir = path.join(projectRoot, '.gait', 'sessions');
+            try {
+                fs.mkdirSync(sessionsDir, { recursive: true });
+                logFilePath = path.join(sessionsDir, `${sessionId}.log`);
+                // Create log file with session header
+                const logHeader = `# Terminal Session Log\n# Session ID: ${sessionId}\n# Proposal ID: ${proposalId}\n# Created: ${new Date().toISOString()}\n\n`;
+                fs.writeFileSync(logFilePath, logHeader);
+            }
+            catch (error) {
+                console.error('Error setting up session logging:', error);
+                logFilePath = undefined;
+            }
+        }
+        // Get shell arguments
+        const shellArgs = getShellArgs(shellPath, initScriptPath);
+        // Prepare environment variables
+        const env = {
+            ...process.env,
+            GAIT_PROPOSAL_ID: proposalId,
+            GAIT_CONTEXT_PATH: path.join(projectRoot, '.gait', 'context'),
+            GAIT_PROPOSAL_PATH: path.join(projectRoot, '.gait', 'proposals', `${proposalId}.md`),
+            TERM: 'xterm-256color',
+            COLORTERM: 'truecolor',
+        };
+        // Add special environment variable for zsh if needed
+        if (tempDirForZsh) {
+            env.ZDOTDIR = tempDirForZsh;
+        }
+        // Create PTY with environment variables for context
+        const ptyProcess = pty.spawn(shellPath, shellArgs, {
+            name: 'xterm-color',
+            cols: 80,
+            rows: 24,
+            cwd: projectRoot,
+            env,
+        });
+        const session = {
+            id: sessionId,
+            proposalId,
+            pty: ptyProcess,
+            createdAt: new Date(),
+            lastActivity: new Date(),
+            enableLogging,
+            logFilePath,
+        };
+        this.sessions.set(sessionId, session);
+        // Set up PTY event handlers
+        ptyProcess.onData((data) => {
+            session.lastActivity = new Date();
+            // Log data if logging is enabled
+            if (session.enableLogging && session.logFilePath) {
+                try {
+                    const timestamp = new Date().toISOString();
+                    const logEntry = `[${timestamp}] OUTPUT: ${data}`;
+                    fs.appendFileSync(session.logFilePath, logEntry);
+                }
+                catch (error) {
+                    console.error('Error writing to session log:', error);
+                }
+            }
+            if (session.websocket && session.websocket.readyState === WebSocket.OPEN) {
+                session.websocket.send(JSON.stringify({
+                    type: 'data',
+                    data: data,
+                }));
+            }
+        });
+        ptyProcess.onExit((e) => {
+            // Log session end if logging is enabled
+            if (session.enableLogging && session.logFilePath) {
+                try {
+                    const timestamp = new Date().toISOString();
+                    const logEntry = `\n[${timestamp}] SESSION ENDED: Exit code ${e.exitCode}\n`;
+                    fs.appendFileSync(session.logFilePath, logEntry);
+                }
+                catch (error) {
+                    console.error('Error writing session end to log:', error);
+                }
+            }
+            // Clean up init script and temp directories
+            try {
+                if (fs.existsSync(initScriptPath)) {
+                    fs.unlinkSync(initScriptPath);
+                }
+                // Clean up zsh temp directory if it exists
+                if (tempDirForZsh && fs.existsSync(tempDirForZsh)) {
+                    fs.rmSync(tempDirForZsh, { recursive: true, force: true });
+                }
+            }
+            catch (error) {
+                console.error('Error cleaning up init script:', error);
+            }
+            if (session.websocket && session.websocket.readyState === WebSocket.OPEN) {
+                session.websocket.send(JSON.stringify({
+                    type: 'exit',
+                    exitCode: e.exitCode,
+                }));
+            }
+            this.destroySession(sessionId);
+        });
+        return session;
+    }
+    getSession(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    getSessionsByProposal(proposalId) {
+        return Array.from(this.sessions.values()).filter(session => session.proposalId === proposalId);
+    }
+    attachWebSocket(sessionId, ws) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return false;
+        }
+        session.websocket = ws;
+        session.lastActivity = new Date();
+        // Set up WebSocket event handlers
+        ws.on('message', (message) => {
+            try {
+                const data = JSON.parse(message.toString());
+                switch (data.type) {
+                    case 'input':
+                        // Log input if logging is enabled
+                        if (session.enableLogging && session.logFilePath) {
+                            try {
+                                const timestamp = new Date().toISOString();
+                                const logEntry = `[${timestamp}] INPUT: ${data.data}`;
+                                fs.appendFileSync(session.logFilePath, logEntry);
+                            }
+                            catch (error) {
+                                console.error('Error writing input to session log:', error);
+                            }
+                        }
+                        session.pty.write(data.data);
+                        session.lastActivity = new Date();
+                        break;
+                    case 'resize':
+                        session.pty.resize(data.cols, data.rows);
+                        break;
+                }
+            }
+            catch (error) {
+                console.error('Error processing WebSocket message:', error);
+            }
+        });
+        ws.on('close', () => {
+            if (session.websocket === ws) {
+                session.websocket = undefined;
+            }
+        });
+        ws.on('error', (error) => {
+            console.error('WebSocket error:', error);
+            if (session.websocket === ws) {
+                session.websocket = undefined;
+            }
+        });
+        return true;
+    }
+    destroySession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return false;
+        }
+        // Close WebSocket if connected
+        if (session.websocket && session.websocket.readyState === WebSocket.OPEN) {
+            session.websocket.close();
+        }
+        // Kill PTY process
+        try {
+            session.pty.kill();
+        }
+        catch (error) {
+            console.error('Error killing PTY process:', error);
+        }
+        this.sessions.delete(sessionId);
+        return true;
+    }
+    resizeSession(sessionId, cols, rows) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return false;
+        }
+        try {
+            session.pty.resize(cols, rows);
+            session.lastActivity = new Date();
+            return true;
+        }
+        catch (error) {
+            console.error('Error resizing terminal:', error);
+            return false;
+        }
+    }
+    cleanupInactiveSessions() {
+        const now = new Date();
+        const maxInactiveTime = 30 * 60 * 1000; // 30 minutes
+        for (const [sessionId, session] of Array.from(this.sessions.entries())) {
+            const inactiveTime = now.getTime() - session.lastActivity.getTime();
+            if (inactiveTime > maxInactiveTime) {
+                console.log(`Cleaning up inactive session: ${sessionId}`);
+                this.destroySession(sessionId);
+            }
+        }
+    }
+    getAllSessions() {
+        return Array.from(this.sessions.values());
+    }
+    destroy() {
+        // Clean up all sessions
+        for (const sessionId of Array.from(this.sessions.keys())) {
+            this.destroySession(sessionId);
+        }
+        // Clear cleanup interval
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+        }
+    }
+}
+// We'll use the global manager instead of creating a direct export

package/dist/lib/user-preferences.d.ts

@@ -0,0 +1,48 @@
+export interface UserProfile {
+    firstName?: string;
+    lastName?: string;
+    email?: string;
+    role?: 'developer' | 'designer' | 'product-manager' | 'other';
+}
+export interface UserPreferences {
+    theme?: 'light' | 'dark' | 'coconut' | 'system';
+    defaultEditor?: 'cursor' | 'vscode' | 'vim' | 'emacs';
+    terminalShell?: 'bash' | 'zsh' | 'fish' | 'sh' | 'system';
+    autoSaveInterval?: number;
+    notifications?: {
+        email?: boolean;
+        desktop?: boolean;
+        slack?: boolean;
+    };
+}
+export interface UserSettings {
+    profile: UserProfile;
+    preferences: UserPreferences;
+}
+/**
+ * Ensure the ~/.gait directory exists
+ */
+export declare function ensureGaitHomeDirectory(): Promise<void>;
+/**
+ * Load user settings from ~/.gait/user-settings.json
+ */
+export declare function loadUserSettings(): Promise<UserSettings>;
+/**
+ * Save user settings to ~/.gait/user-settings.json
+ */
+export declare function saveUserSettings(settings: UserSettings): Promise<void>;
+/**
+ * Update user profile information
+ */
+export declare function updateUserProfile(profile: Partial<UserProfile>): Promise<UserSettings>;
+/**
+ * Update user preferences
+ */
+export declare function updateUserPreferences(preferences: Partial<UserPreferences>): Promise<UserSettings>;
+/**
+ * Get the author information for Change Proposals
+ */
+export declare function getAuthorInfo(): Promise<{
+    name: string;
+    email: string;
+}>;

package/dist/lib/user-preferences.js

@@ -0,0 +1,87 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+const GAIT_HOME_DIR = path.join(os.homedir(), '.gait');
+const USER_SETTINGS_FILE = path.join(GAIT_HOME_DIR, 'user-settings.json');
+/**
+ * Ensure the ~/.gait directory exists
+ */
+export async function ensureGaitHomeDirectory() {
+    try {
+        await fs.access(GAIT_HOME_DIR);
+    }
+    catch {
+        await fs.mkdir(GAIT_HOME_DIR, { recursive: true });
+    }
+}
+/**
+ * Load user settings from ~/.gait/user-settings.json
+ */
+export async function loadUserSettings() {
+    try {
+        await ensureGaitHomeDirectory();
+        const data = await fs.readFile(USER_SETTINGS_FILE, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        // Return default settings if file doesn't exist or is invalid
+        return {
+            profile: {},
+            preferences: {
+                theme: 'system',
+                defaultEditor: 'cursor',
+                terminalShell: 'bash',
+                autoSaveInterval: 30,
+                notifications: {
+                    email: true,
+                    desktop: true,
+                    slack: false,
+                },
+            },
+        };
+    }
+}
+/**
+ * Save user settings to ~/.gait/user-settings.json
+ */
+export async function saveUserSettings(settings) {
+    await ensureGaitHomeDirectory();
+    await fs.writeFile(USER_SETTINGS_FILE, JSON.stringify(settings, null, 2), 'utf-8');
+}
+/**
+ * Update user profile information
+ */
+export async function updateUserProfile(profile) {
+    const settings = await loadUserSettings();
+    settings.profile = { ...settings.profile, ...profile };
+    await saveUserSettings(settings);
+    return settings;
+}
+/**
+ * Update user preferences
+ */
+export async function updateUserPreferences(preferences) {
+    const settings = await loadUserSettings();
+    settings.preferences = {
+        ...settings.preferences,
+        ...preferences,
+        notifications: {
+            ...settings.preferences.notifications,
+            ...preferences.notifications,
+        }
+    };
+    await saveUserSettings(settings);
+    return settings;
+}
+/**
+ * Get the author information for Change Proposals
+ */
+export async function getAuthorInfo() {
+    const settings = await loadUserSettings();
+    const { firstName, lastName, email } = settings.profile;
+    const name = [firstName, lastName].filter(Boolean).join(' ') || 'Current User';
+    return {
+        name,
+        email: email || 'user@example.com',
+    };
+}

package/dist/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): any;

package/dist/lib/utils.js

@@ -0,0 +1,5 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/dist/routes/api/symlink-status/route.d.ts

@@ -0,0 +1 @@
+export declare function GET(): Promise<any>;