@lovelybunch/api 1.0.7

package/dist/lib/symlinks/symlink-manager.js

@@ -0,0 +1,444 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+/**
+ * SymlinkManager handles all symlink operations and persists state
+ */
+export class SymlinkManager {
+    configPath;
+    projectRoot;
+    state;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+        this.configPath = path.join(projectRoot, '.gait', 'symlinks.json');
+        this.state = {
+            version: '1.0.0',
+            symlinks: []
+        };
+    }
+    /**
+     * Initialize the manager and load existing configuration
+     */
+    async initialize() {
+        try {
+            console.log(`[SymlinkManager] Initializing with project root: ${this.projectRoot}`);
+            console.log(`[SymlinkManager] Config path: ${this.configPath}`);
+            // Ensure .gait directory exists
+            const gaitDir = path.join(this.projectRoot, '.gait');
+            await fs.mkdir(gaitDir, { recursive: true });
+            // Try to load existing configuration
+            try {
+                const configData = await fs.readFile(this.configPath, 'utf-8');
+                this.state = JSON.parse(configData);
+                console.log(`[SymlinkManager] Loaded ${this.state.symlinks.length} symlinks from config`);
+                // Validate state against actual filesystem
+                await this.validateSymlinks();
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    console.log('[SymlinkManager] No existing config found, creating default');
+                    // Config doesn't exist, create default
+                    await this.createDefaultConfig();
+                }
+                else {
+                    console.error('[SymlinkManager] Error loading config:', error);
+                    throw error;
+                }
+            }
+        }
+        catch (error) {
+            console.error('[SymlinkManager] Failed to initialize:', error);
+            throw error;
+        }
+    }
+    /**
+     * Create default configuration with the CLAUDE.md symlink
+     */
+    async createDefaultConfig() {
+        // Check if the legacy CLAUDE.md symlink exists
+        const claudeSymlinkPath = path.join(this.projectRoot, 'CLAUDE.md');
+        let isActive = false;
+        try {
+            const stats = await fs.lstat(claudeSymlinkPath);
+            isActive = stats.isSymbolicLink();
+        }
+        catch {
+            // Symlink doesn't exist
+        }
+        const defaultSymlink = {
+            id: 'claude-rules',
+            name: 'Claude Rules',
+            description: 'Project-specific rules and guidelines for Claude AI assistant',
+            linkPath: 'CLAUDE.md',
+            targetPath: '.gait/rules/CLAUDE.md',
+            isActive,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString()
+        };
+        this.state.symlinks = [defaultSymlink];
+        await this.saveState();
+    }
+    /**
+     * Validate symlinks against actual filesystem state
+     */
+    async validateSymlinks() {
+        for (const symlink of this.state.symlinks) {
+            // Expand tilde and resolve path
+            const expandedLinkPath = this.expandTilde(symlink.linkPath);
+            const fullLinkPath = path.isAbsolute(expandedLinkPath)
+                ? expandedLinkPath
+                : path.join(this.projectRoot, expandedLinkPath);
+            try {
+                const stats = await fs.lstat(fullLinkPath);
+                const actuallyActive = stats.isSymbolicLink();
+                if (actuallyActive !== symlink.isActive) {
+                    // State mismatch - filesystem is source of truth
+                    symlink.isActive = actuallyActive;
+                    symlink.updatedAt = new Date().toISOString();
+                }
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    // File doesn't exist
+                    if (symlink.isActive) {
+                        symlink.isActive = false;
+                        symlink.updatedAt = new Date().toISOString();
+                    }
+                }
+            }
+        }
+        await this.saveState();
+    }
+    /**
+     * Save current state to configuration file
+     */
+    async saveState() {
+        try {
+            // Ensure directory exists
+            await fs.mkdir(path.dirname(this.configPath), { recursive: true });
+            // Write to temp file first
+            const tempPath = `${this.configPath}.tmp`;
+            await fs.writeFile(tempPath, JSON.stringify(this.state, null, 2), 'utf-8');
+            // Atomic rename
+            await fs.rename(tempPath, this.configPath);
+            console.log(`[SymlinkManager] Saved state with ${this.state.symlinks.length} symlinks to ${this.configPath}`);
+        }
+        catch (error) {
+            console.error('[SymlinkManager] Failed to save state:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get all symlink configurations
+     */
+    async getSymlinks() {
+        await this.validateSymlinks();
+        return this.state.symlinks;
+    }
+    /**
+     * Get a specific symlink by ID
+     */
+    async getSymlink(id) {
+        await this.validateSymlinks();
+        return this.state.symlinks.find(s => s.id === id);
+    }
+    /**
+     * Add a new symlink configuration
+     */
+    async addSymlink(config) {
+        try {
+            // Check if link path already exists
+            if (this.state.symlinks.some(s => s.linkPath === config.linkPath)) {
+                return {
+                    success: false,
+                    message: `A symlink at ${config.linkPath} already exists`
+                };
+            }
+            const newSymlink = {
+                ...config,
+                id: `symlink-${Date.now()}`,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            };
+            this.state.symlinks.push(newSymlink);
+            if (config.isActive) {
+                const result = await this.createSymlink(newSymlink.id);
+                if (!result.success) {
+                    // Roll back
+                    this.state.symlinks = this.state.symlinks.filter(s => s.id !== newSymlink.id);
+                    return result;
+                }
+            }
+            await this.saveState();
+            return {
+                success: true,
+                message: 'Symlink configuration added successfully',
+                symlink: newSymlink
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: 'Failed to add symlink',
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Toggle a symlink on/off
+     */
+    async toggleSymlink(id) {
+        const symlink = this.state.symlinks.find(s => s.id === id);
+        if (!symlink) {
+            return {
+                success: false,
+                message: `Symlink with ID ${id} not found`
+            };
+        }
+        if (symlink.isActive) {
+            return await this.removeSymlink(id);
+        }
+        else {
+            return await this.createSymlink(id);
+        }
+    }
+    /**
+     * Expand tilde in path to actual home directory
+     */
+    expandTilde(filepath) {
+        if (filepath.startsWith('~/')) {
+            return path.join(os.homedir(), filepath.slice(2));
+        }
+        return filepath;
+    }
+    /**
+     * Create a symlink on the filesystem
+     */
+    async createSymlink(id) {
+        const symlink = this.state.symlinks.find(s => s.id === id);
+        if (!symlink) {
+            return {
+                success: false,
+                message: `Symlink with ID ${id} not found`
+            };
+        }
+        try {
+            // Expand tilde in paths and resolve them
+            const expandedLinkPath = this.expandTilde(symlink.linkPath);
+            const expandedTargetPath = this.expandTilde(symlink.targetPath);
+            // If paths are relative (not starting with / or ~), make them relative to project root
+            const fullLinkPath = path.isAbsolute(expandedLinkPath)
+                ? expandedLinkPath
+                : path.join(this.projectRoot, expandedLinkPath);
+            const fullTargetPath = path.isAbsolute(expandedTargetPath)
+                ? expandedTargetPath
+                : path.join(this.projectRoot, expandedTargetPath);
+            // Ensure target exists
+            try {
+                await fs.access(fullTargetPath);
+            }
+            catch {
+                // Create target directory and file if needed
+                await fs.mkdir(path.dirname(fullTargetPath), { recursive: true });
+                // Create a default file if it doesn't exist
+                await fs.writeFile(fullTargetPath, `# ${symlink.name}
+
+${symlink.description || 'Configuration file'}
+
+Created: ${new Date().toISOString()}
+`);
+            }
+            // Remove existing file/symlink if it exists
+            try {
+                await fs.unlink(fullLinkPath);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+            // Create the symlink (use relative path for portability)
+            const relativePath = path.relative(path.dirname(fullLinkPath), fullTargetPath);
+            await fs.symlink(relativePath, fullLinkPath);
+            symlink.isActive = true;
+            symlink.updatedAt = new Date().toISOString();
+            await this.saveState();
+            return {
+                success: true,
+                message: `Symlink ${symlink.name} created successfully`,
+                symlink
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to create symlink`,
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Remove a symlink from the filesystem
+     */
+    async removeSymlink(id) {
+        const symlink = this.state.symlinks.find(s => s.id === id);
+        if (!symlink) {
+            return {
+                success: false,
+                message: `Symlink with ID ${id} not found`
+            };
+        }
+        try {
+            // Expand tilde and resolve path
+            const expandedLinkPath = this.expandTilde(symlink.linkPath);
+            const fullLinkPath = path.isAbsolute(expandedLinkPath)
+                ? expandedLinkPath
+                : path.join(this.projectRoot, expandedLinkPath);
+            try {
+                const stats = await fs.lstat(fullLinkPath);
+                if (stats.isSymbolicLink()) {
+                    await fs.unlink(fullLinkPath);
+                }
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+            symlink.isActive = false;
+            symlink.updatedAt = new Date().toISOString();
+            await this.saveState();
+            return {
+                success: true,
+                message: `Symlink ${symlink.name} removed successfully`,
+                symlink
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to remove symlink`,
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Delete a symlink configuration entirely
+     */
+    async deleteSymlink(id) {
+        const symlink = this.state.symlinks.find(s => s.id === id);
+        if (!symlink) {
+            return {
+                success: false,
+                message: `Symlink with ID ${id} not found`
+            };
+        }
+        // Remove from filesystem first if active
+        if (symlink.isActive) {
+            await this.removeSymlink(id);
+        }
+        // Remove from configuration
+        this.state.symlinks = this.state.symlinks.filter(s => s.id !== id);
+        await this.saveState();
+        return {
+            success: true,
+            message: `Symlink configuration deleted successfully`
+        };
+    }
+    /**
+     * Update a symlink configuration
+     */
+    async updateSymlink(id, updates) {
+        const symlink = this.state.symlinks.find(s => s.id === id);
+        if (!symlink) {
+            return {
+                success: false,
+                message: `Symlink with ID ${id} not found`
+            };
+        }
+        try {
+            // If changing paths and symlink is active, need to recreate
+            if (symlink.isActive && (updates.linkPath || updates.targetPath)) {
+                await this.removeSymlink(id);
+            }
+            // Apply updates
+            Object.assign(symlink, updates, {
+                updatedAt: new Date().toISOString()
+            });
+            // Recreate if was active and paths changed
+            if (symlink.isActive && (updates.linkPath || updates.targetPath)) {
+                const result = await this.createSymlink(id);
+                if (!result.success) {
+                    return result;
+                }
+            }
+            await this.saveState();
+            return {
+                success: true,
+                message: 'Symlink updated successfully',
+                symlink
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: 'Failed to update symlink',
+                error: error.message
+            };
+        }
+    }
+}
+// Singleton instance and initialization promise
+let managerInstance = null;
+let initializationPromise = null;
+/**
+ * Get or create the SymlinkManager instance
+ */
+export async function getSymlinkManager() {
+    // If already initializing, wait for that to complete
+    if (initializationPromise) {
+        return initializationPromise;
+    }
+    // If already initialized, return the instance
+    if (managerInstance) {
+        return managerInstance;
+    }
+    // Start initialization
+    initializationPromise = (async () => {
+        try {
+            // Determine project root more reliably
+            let projectRoot = process.env.GAIT_PROJECT_ROOT;
+            if (!projectRoot) {
+                // Try to find the project root by looking for distinctive files
+                const cwd = process.cwd();
+                // Check if we're in packages/web
+                if (cwd.includes('packages/web')) {
+                    projectRoot = path.resolve(cwd, '../..');
+                }
+                else if (cwd.includes('packages')) {
+                    projectRoot = path.resolve(cwd, '..');
+                }
+                else {
+                    projectRoot = cwd;
+                }
+                // Verify this is the right directory by checking for .gait
+                try {
+                    await fs.access(path.join(projectRoot, '.gait'));
+                }
+                catch {
+                    console.warn(`Could not find .gait directory at ${projectRoot}, using cwd`);
+                    projectRoot = cwd;
+                }
+            }
+            console.log(`[SymlinkManager] Using project root: ${projectRoot}`);
+            managerInstance = new SymlinkManager(projectRoot);
+            await managerInstance.initialize();
+            return managerInstance;
+        }
+        catch (error) {
+            // Reset on error so we can retry
+            initializationPromise = null;
+            managerInstance = null;
+            throw error;
+        }
+    })();
+    return initializationPromise;
+}

package/dist/lib/symlinks/types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Symlink configuration types
+ */
+export interface SymlinkConfig {
+    id: string;
+    name: string;
+    description?: string;
+    linkPath: string;
+    targetPath: string;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface SymlinksState {
+    version: string;
+    symlinks: SymlinkConfig[];
+}
+export interface SymlinkOperationResult {
+    success: boolean;
+    message: string;
+    error?: string;
+    symlink?: SymlinkConfig;
+}

package/dist/lib/symlinks/types.js

@@ -0,0 +1,4 @@
+/**
+ * Symlink configuration types
+ */
+export {};

package/dist/lib/terminal/context-helper.d.ts

@@ -0,0 +1,11 @@
+export interface ContextInfo {
+    proposalId: string;
+    proposalPath: string;
+    contextPath: string;
+    projectRoot: string;
+}
+export declare function generateWelcomeMessage(context: ContextInfo): string;
+export declare function generateClaudeSetupCommands(context: ContextInfo): string[];
+export declare function generateContextCommands(_context: ContextInfo): string[];
+export declare function generateBashAliases(_context: ContextInfo): string[];
+export declare function createInitScript(context: ContextInfo): string;

package/dist/lib/terminal/context-helper.js

@@ -0,0 +1,164 @@
+// Context helper functions for terminal sessions
+// These can be used to generate helpful commands and information
+export function generateWelcomeMessage(context) {
+    return `
+\x1b[32m╭─────────────────────────────────────────────────────────────╮\x1b[0m
+\x1b[32m│                    GAIT Terminal Session                    │\x1b[0m
+\x1b[32m╰─────────────────────────────────────────────────────────────╯\x1b[0m
+
+\x1b[36mProposal:\x1b[0m ${context.proposalId}
+\x1b[36mProject Root:\x1b[0m ${context.projectRoot}
+
+\x1b[33mAvailable Environment Variables:\x1b[0m
+  GAIT_PROPOSAL_ID="${context.proposalId}"
+  GAIT_CONTEXT_PATH="${context.contextPath}"
+  GAIT_PROPOSAL_PATH="${context.proposalPath}"
+
+\x1b[33mQuick Commands:\x1b[0m
+  \x1b[32mgait-help\x1b[0m        - Show this help message
+  \x1b[32mgait-proposal\x1b[0m    - View current proposal
+  \x1b[32mgait-files\x1b[0m       - List context files
+  \x1b[32mgait-claude\x1b[0m      - Setup Claude Code CLI
+
+\x1b[90mTip: Use 'gait-claude' to configure Claude Code for this proposal\x1b[0m
+
+`;
+}
+export function generateClaudeSetupCommands(context) {
+    return [
+        '# Claude Code CLI Setup Commands',
+        '# Run these commands to configure Claude Code for this proposal:',
+        '',
+        '# 1. Set the working directory context',
+        `export CLAUDE_CONTEXT_PATH="${context.contextPath}"`,
+        `export CLAUDE_PROPOSAL_PATH="${context.proposalPath}"`,
+        '',
+        '# 2. Create a Claude Code project configuration',
+        'cat > .claude-project.json << EOF',
+        '{',
+        `  "name": "GAIT Proposal ${context.proposalId}",`,
+        `  "description": "Working on proposal ${context.proposalId}",`,
+        '  "context": [',
+        `    "${context.proposalPath}",`,
+        `    "${context.contextPath}/project.md",`,
+        `    "${context.contextPath}/architecture.md",`,
+        '  ],',
+        '  "rules": [',
+        '    "Follow the project architecture patterns",',
+        '    "Reference the proposal requirements",',
+        '    "Maintain consistency with existing code"',
+        '  ]',
+        '}',
+        'EOF',
+        '',
+        '# 3. Start Claude Code with context',
+        'claude-code --project .claude-project.json',
+        '',
+        '# Alternative: Direct command with context files',
+        `claude-code --context "${context.proposalPath}" --context "${context.contextPath}/project.md"`,
+    ];
+}
+export function generateContextCommands(_context) {
+    return [
+        '# Context File Commands',
+        '# Use these commands to explore the project context:',
+        '',
+        '# View the current proposal',
+        `cat "$GAIT_PROPOSAL_PATH"`,
+        '',
+        '# View project overview',
+        `cat "$GAIT_CONTEXT_PATH/project.md"`,
+        '',
+        '# View architecture documentation',
+        `cat "$GAIT_CONTEXT_PATH/architecture.md"`,
+        '',
+        '',
+        '# List all context files',
+        `find "$GAIT_CONTEXT_PATH" -name "*.md" -type f`,
+        '',
+        '# Search for specific terms in context',
+        `grep -r "search_term" "$GAIT_CONTEXT_PATH"`,
+    ];
+}
+export function generateBashAliases(_context) {
+    return [];
+}
+export function createInitScript(context) {
+    return `#!/bin/bash
+# GAIT Terminal Initialization Script
+# This script is automatically sourced when a terminal session starts
+
+# Function to show context help
+gait-context-help() {
+  cat << 'GAIT_HELP_EOF'
+${generateWelcomeMessage(context)}
+GAIT_HELP_EOF
+}
+
+# Function to show proposal content
+gait-proposal() {
+  if [ -f "$GAIT_PROPOSAL_PATH" ]; then
+    echo "\\x1b[36m=== Proposal: $GAIT_PROPOSAL_ID ===\\x1b[0m"
+    cat "$GAIT_PROPOSAL_PATH"
+  else
+    echo "\\x1b[31mProposal file not found: $GAIT_PROPOSAL_PATH\\x1b[0m"
+  fi
+}
+
+# Function to list context files
+gait-files() {
+  echo "\\x1b[36m=== Context Files ===\\x1b[0m"
+  if [ -d "$GAIT_CONTEXT_PATH" ]; then
+    find "$GAIT_CONTEXT_PATH" -name "*.md" -type f | sort
+  else
+    echo "\\x1b[31mContext directory not found: $GAIT_CONTEXT_PATH\\x1b[0m"
+  fi
+}
+
+# Function to setup Claude Code
+gait-claude() {
+  echo "\\x1b[36m=== Claude Code Setup ===\\x1b[0m"
+  
+  # Check if Claude Code is available
+  if ! command -v claude-code &> /dev/null; then
+    echo "\\x1b[33mClaude Code CLI not found. Please install it first:\\x1b[0m"
+    echo "npm install -g @anthropic-ai/claude-code"
+    return 1
+  fi
+  
+  # Create project configuration
+  cat > .claude-project.json << 'EOF'
+{
+  "name": "GAIT Proposal ${context.proposalId}",
+  "description": "Working on proposal ${context.proposalId}",
+  "context": [
+    "${context.proposalPath}",
+    "${context.contextPath}/project.md",
+    "${context.contextPath}/architecture.md",
+  ],
+  "rules": [
+    "Follow the project architecture patterns",
+    "Reference the proposal requirements",
+    "Maintain consistency with existing code"
+  ]
+}
+EOF
+  
+  echo "\\x1b[32mClaude Code project configuration created!\\x1b[0m"
+  echo "\\x1b[33mRun: claude-code --project .claude-project.json\\x1b[0m"
+}
+
+# Create helpful alias for help command
+alias gait-help='gait-context-help'
+
+# Clear screen first to avoid any leftover content
+clear
+
+# Show welcome message
+gait-context-help
+
+# Set a custom prompt to show the proposal ID
+# This will be replaced with shell-specific syntax in prepareShellInit
+export PS1="[${context.proposalId}] \\w $ "
+`;
+}

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

@@ -0,0 +1,2 @@
+import { TerminalManager } from './terminal-manager.js';
+export declare function getGlobalTerminalManager(): TerminalManager;

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

@@ -0,0 +1,15 @@
+import { TerminalManager } from './terminal-manager.js';
+// Use a type assertion to avoid TypeScript conflicts
+const globalAny = global;
+// Initialize the global singleton if it doesn't exist
+const getOrCreateManager = () => {
+    if (!globalAny.gaitTerminalManager) {
+        globalAny.gaitTerminalManager = new TerminalManager();
+    }
+    return globalAny.gaitTerminalManager;
+};
+// Initialize on module load
+getOrCreateManager();
+export function getGlobalTerminalManager() {
+    return getOrCreateManager();
+}