@lovelybunch/api 1.0.7

package/dist/lib/gait-path.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Find the .gait directory by traversing up from the current working directory
+ * If GAIT_DATA_PATH is set (from CLI), use that instead
+ */
+export declare function findGaitDirectory(startDir?: string): Promise<string | null>;
+/**
+ * Get the path to a context file, automatically finding the .gait directory
+ */
+export declare function getContextFilePath(fileName: string): Promise<string | null>;
+/**
+ * Get the .gait config to read storage path settings
+ */
+export declare function getGaitConfig(): Promise<any | null>;

package/dist/lib/gait-path.js

@@ -0,0 +1,57 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+/**
+ * Find the .gait directory by traversing up from the current working directory
+ * If GAIT_DATA_PATH is set (from CLI), use that instead
+ */
+export async function findGaitDirectory(startDir) {
+    // If running from CLI (gait serve), use the directory where command was run
+    if (process.env.GAIT_DATA_PATH) {
+        const gaitPath = path.join(process.env.GAIT_DATA_PATH, '.gait');
+        try {
+            await fs.access(gaitPath);
+            return gaitPath;
+        }
+        catch {
+            // Fall through to directory traversal
+        }
+    }
+    // Otherwise traverse up from start directory
+    let currentDir = startDir || process.cwd();
+    while (currentDir !== path.parse(currentDir).root) {
+        const gaitPath = path.join(currentDir, '.gait');
+        try {
+            await fs.access(gaitPath);
+            return gaitPath;
+        }
+        catch {
+            currentDir = path.dirname(currentDir);
+        }
+    }
+    return null;
+}
+/**
+ * Get the path to a context file, automatically finding the .gait directory
+ */
+export async function getContextFilePath(fileName) {
+    const gaitDir = await findGaitDirectory();
+    if (!gaitDir)
+        return null;
+    return path.join(gaitDir, 'context', fileName);
+}
+/**
+ * Get the .gait config to read storage path settings
+ */
+export async function getGaitConfig() {
+    const gaitDir = await findGaitDirectory();
+    if (!gaitDir)
+        return null;
+    const configPath = path.join(gaitDir, 'config.json');
+    try {
+        const config = await fs.readFile(configPath, 'utf-8');
+        return JSON.parse(config);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/project-paths.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Gets the consistent project root path for GAIT operations.
+ * This ensures that both symlink operations use the same base path.
+ */
+export declare function getProjectRoot(): Promise<string>;
+/**
+ * Gets the path to the CLAUDE.md symlink in the project root
+ */
+export declare function getSymlinkPath(): Promise<string>;
+/**
+ * Gets the path to the actual CLAUDE.md file in .gait/rules
+ */
+export declare function getTargetPath(): Promise<string>;

package/dist/lib/project-paths.js

@@ -0,0 +1,57 @@
+import path from 'path';
+import { promises as fs } from 'fs';
+/**
+ * Gets the consistent project root path for GAIT operations.
+ * This ensures that both symlink operations use the same base path.
+ */
+export async function getProjectRoot() {
+    // First, check if GAIT_DATA_PATH is explicitly set
+    if (process.env.GAIT_DATA_PATH) {
+        return path.resolve(process.env.GAIT_DATA_PATH);
+    }
+    // In development, we need to find the actual project root
+    // Starting from the current working directory
+    let currentPath = process.cwd();
+    // If we're in a Next.js app, we might be in packages/web
+    // We need to traverse up to find the actual project root
+    while (currentPath !== path.dirname(currentPath)) {
+        try {
+            // Check if we're at the project root by looking for distinctive files
+            const possibleRoot = currentPath;
+            const hasPackageJson = await fs.access(path.join(possibleRoot, 'package.json')).then(() => true).catch(() => false);
+            const hasGaitDir = await fs.access(path.join(possibleRoot, '.gait')).then(() => true).catch(() => false);
+            const hasPnpmWorkspace = await fs.access(path.join(possibleRoot, 'pnpm-workspace.yaml')).then(() => true).catch(() => false);
+            // If this looks like the project root, use it
+            if (hasPackageJson && hasGaitDir && hasPnpmWorkspace) {
+                return possibleRoot;
+            }
+            // Otherwise, check parent directory
+            currentPath = path.dirname(currentPath);
+        }
+        catch {
+            currentPath = path.dirname(currentPath);
+        }
+    }
+    // Fallback: if we can't find the project root, use the current working directory
+    // But also try a known relative path from the web package
+    const webPackagePath = process.cwd();
+    if (webPackagePath.includes('packages/web')) {
+        // We're in the web package, go up to the root
+        return path.resolve(webPackagePath, '../..');
+    }
+    return process.cwd();
+}
+/**
+ * Gets the path to the CLAUDE.md symlink in the project root
+ */
+export async function getSymlinkPath() {
+    const projectRoot = await getProjectRoot();
+    return path.join(projectRoot, 'CLAUDE.md');
+}
+/**
+ * Gets the path to the actual CLAUDE.md file in .gait/rules
+ */
+export async function getTargetPath() {
+    const projectRoot = await getProjectRoot();
+    return path.join(projectRoot, '.gait', 'rules', 'CLAUDE.md');
+}

package/dist/lib/storage/file-storage.d.ts

@@ -0,0 +1,28 @@
+import { ChangeProposal, CPStatus } from '@lovelybunch/types';
+export interface CPFilter {
+    status?: CPStatus;
+    author?: string;
+    priority?: string;
+    tags?: string[];
+}
+export interface StorageAdapter {
+    createCP(cp: ChangeProposal): Promise<void>;
+    getCP(id: string): Promise<ChangeProposal | null>;
+    updateCP(id: string, cp: Partial<ChangeProposal>): Promise<void>;
+    deleteCP(id: string): Promise<void>;
+    listCPs(filter?: CPFilter): Promise<ChangeProposal[]>;
+    searchCPs(query: string): Promise<ChangeProposal[]>;
+}
+export declare class FileStorageAdapter implements StorageAdapter {
+    private basePath;
+    constructor(basePath?: string);
+    ensureDirectories(): Promise<void>;
+    createCP(cp: ChangeProposal): Promise<void>;
+    getCP(id: string): Promise<ChangeProposal | null>;
+    updateCP(id: string, updates: Partial<ChangeProposal>): Promise<void>;
+    deleteCP(id: string): Promise<void>;
+    listCPs(filter?: CPFilter): Promise<ChangeProposal[]>;
+    searchCPs(query: string): Promise<ChangeProposal[]>;
+    private frontmatterToCP;
+    private getDefaultContent;
+}

package/dist/lib/storage/file-storage.js

@@ -0,0 +1,224 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+import Fuse from 'fuse.js';
+export class FileStorageAdapter {
+    basePath;
+    constructor(basePath) {
+        // Use environment variable if available (for web server), otherwise default to .gait
+        this.basePath = basePath || (process.env.GAIT_DATA_PATH ?
+            path.join(process.env.GAIT_DATA_PATH, '.gait') :
+            '.gait');
+    }
+    async ensureDirectories() {
+        const dirs = ['proposals', 'specs', 'flags', 'experiments', 'templates'];
+        for (const dir of dirs) {
+            await fs.mkdir(path.join(this.basePath, dir), { recursive: true });
+        }
+    }
+    async createCP(cp) {
+        await this.ensureDirectories();
+        // Extract content from the proposal if it exists
+        const { content, ...frontmatter } = cp;
+        // Convert the proposal to markdown with YAML frontmatter
+        const markdown = matter.stringify(content || this.getDefaultContent(cp), {
+            // Required fields
+            id: cp.id,
+            intent: cp.intent,
+            createdAt: cp.metadata.createdAt.toISOString(),
+            updatedAt: cp.metadata.updatedAt.toISOString(),
+            status: cp.status,
+            priority: cp.metadata.priority || 'medium',
+            // Author information
+            author: {
+                id: cp.author.id,
+                name: cp.author.name,
+                email: cp.author.email || '',
+                role: 'engineer', // Default role
+                type: cp.author.type
+            },
+            // Plan
+            plan: {
+                estimatedDuration: 'TBD',
+                dependencies: [],
+                steps: cp.planSteps.map(step => ({
+                    id: step.id,
+                    description: step.description,
+                    status: step.status
+                }))
+            },
+            // Metadata
+            tags: cp.metadata.tags || [],
+            labels: [],
+            comments: cp.comments || []
+        });
+        const filePath = path.join(this.basePath, 'proposals', `${cp.id}.md`);
+        await fs.writeFile(filePath, markdown, 'utf-8');
+    }
+    async getCP(id) {
+        try {
+            const filePath = path.join(this.basePath, 'proposals', `${id}.md`);
+            const fileContent = await fs.readFile(filePath, 'utf-8');
+            const { data, content } = matter(fileContent);
+            // Convert the frontmatter back to a ChangeProposal
+            return this.frontmatterToCP(data, content);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return null;
+            throw error;
+        }
+    }
+    async updateCP(id, updates) {
+        const existing = await this.getCP(id);
+        if (!existing)
+            throw new Error(`CP ${id} not found`);
+        // Handle comments separately as they're stored at root level in file format
+        let updated = {
+            ...existing,
+            ...updates,
+            metadata: {
+                ...existing.metadata,
+                ...updates.metadata,
+                updatedAt: new Date()
+            }
+        };
+        // If comments are being updated, store them at the root level for the file format
+        if (updates.comments) {
+            updated.comments = updates.comments;
+        }
+        await this.createCP(updated);
+    }
+    async deleteCP(id) {
+        const filePath = path.join(this.basePath, 'proposals', `${id}.md`);
+        await fs.unlink(filePath);
+    }
+    async listCPs(filter) {
+        const proposalsDir = path.join(this.basePath, 'proposals');
+        try {
+            const files = await fs.readdir(proposalsDir);
+            const proposals = await Promise.all(files
+                .filter(f => f.endsWith('.md'))
+                .map(async (file) => {
+                const content = await fs.readFile(path.join(proposalsDir, file), 'utf-8');
+                const { data, content: body } = matter(content);
+                return this.frontmatterToCP(data, body);
+            }));
+            // Apply filters
+            return proposals.filter(cp => {
+                if (!cp)
+                    return false;
+                if (filter?.status && cp.status !== filter.status)
+                    return false;
+                if (filter?.author && cp.author.id !== filter.author)
+                    return false;
+                if (filter?.priority && cp.metadata.priority !== filter.priority)
+                    return false;
+                if (filter?.tags && filter.tags.length > 0) {
+                    const cpTags = cp.metadata.tags || [];
+                    if (!filter.tags.some(tag => cpTags.includes(tag)))
+                        return false;
+                }
+                return true;
+            }).filter(Boolean);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+    }
+    async searchCPs(query) {
+        const allCPs = await this.listCPs();
+        const fuse = new Fuse(allCPs, {
+            keys: [
+                { name: 'intent', weight: 2 },
+                { name: 'content', weight: 1 },
+                { name: 'author.name', weight: 0.5 },
+                { name: 'metadata.tags', weight: 1 }
+            ],
+            threshold: 0.3,
+            includeScore: true
+        });
+        return fuse.search(query).map(result => result.item);
+    }
+    frontmatterToCP(data, content) {
+        // Handle both old and new format files
+        const steps = data.plan?.steps || data.steps || [];
+        // Transform comments to match expected format
+        const transformedComments = (data.comments || []).map((comment) => ({
+            id: comment.id,
+            text: comment.content || comment.text || '', // Handle both content and text fields
+            author: typeof comment.author === 'string' ? comment.author : comment.author?.name || 'Unknown',
+            timestamp: comment.createdAt || comment.timestamp || new Date().toISOString()
+        }));
+        return {
+            id: data.id,
+            intent: data.intent,
+            author: {
+                id: data.author?.id || data.author?.name || 'unknown',
+                name: data.author?.name || 'Unknown',
+                email: data.author?.email,
+                type: data.author?.type || 'human'
+            },
+            productSpecRef: data.productSpecRef,
+            planSteps: steps.map((step) => ({
+                id: step.id || `step-${Date.now()}`,
+                description: step.description || step.title || 'Unnamed step',
+                status: step.status || 'pending',
+                command: step.command,
+                expectedOutcome: step.expectedOutcome,
+                output: step.output,
+                error: step.error,
+                executedAt: step.executedAt ? new Date(step.executedAt) : undefined
+            })),
+            evidence: data.evidence || [],
+            policies: data.policies || [],
+            featureFlags: data.featureFlags || [],
+            experiments: data.experiments || [],
+            telemetryContracts: data.telemetryContracts || [],
+            releasePlan: data.releasePlan || { strategy: 'immediate' },
+            status: data.status || 'draft',
+            metadata: {
+                createdAt: new Date(data.createdAt || Date.now()),
+                updatedAt: new Date(data.updatedAt || Date.now()),
+                reviewers: data.reviewers || [],
+                aiInteractions: data.aiInteractions || [],
+                tags: data.tags || [],
+                priority: data.priority || 'medium',
+                comments: transformedComments
+            },
+            content // Store the markdown content
+        };
+    }
+    getDefaultContent(cp) {
+        return `# ${cp.intent}
+
+## Problem Statement
+Describe the problem this change proposal addresses.
+
+## Proposed Solution
+Describe the solution you're proposing.
+
+### Key Features
+- Feature 1
+- Feature 2
+- Feature 3
+
+## Implementation Details
+Describe the technical implementation approach.
+
+## Testing Strategy
+- [ ] Unit tests
+- [ ] Integration tests  
+- [ ] Manual testing
+
+## Rollout Plan
+1. Development and testing
+2. Staging deployment
+3. Production rollout
+
+## Success Metrics
+Define how you'll measure the success of this change.`;
+    }
+}

package/dist/lib/symlinks/symlink-manager.d.ts

@@ -0,0 +1,66 @@
+import { SymlinkConfig, SymlinkOperationResult } from './types.js';
+/**
+ * SymlinkManager handles all symlink operations and persists state
+ */
+export declare class SymlinkManager {
+    private configPath;
+    private projectRoot;
+    private state;
+    constructor(projectRoot: string);
+    /**
+     * Initialize the manager and load existing configuration
+     */
+    initialize(): Promise<void>;
+    /**
+     * Create default configuration with the CLAUDE.md symlink
+     */
+    private createDefaultConfig;
+    /**
+     * Validate symlinks against actual filesystem state
+     */
+    private validateSymlinks;
+    /**
+     * Save current state to configuration file
+     */
+    private saveState;
+    /**
+     * Get all symlink configurations
+     */
+    getSymlinks(): Promise<SymlinkConfig[]>;
+    /**
+     * Get a specific symlink by ID
+     */
+    getSymlink(id: string): Promise<SymlinkConfig | undefined>;
+    /**
+     * Add a new symlink configuration
+     */
+    addSymlink(config: Omit<SymlinkConfig, 'id' | 'createdAt' | 'updatedAt'>): Promise<SymlinkOperationResult>;
+    /**
+     * Toggle a symlink on/off
+     */
+    toggleSymlink(id: string): Promise<SymlinkOperationResult>;
+    /**
+     * Expand tilde in path to actual home directory
+     */
+    private expandTilde;
+    /**
+     * Create a symlink on the filesystem
+     */
+    private createSymlink;
+    /**
+     * Remove a symlink from the filesystem
+     */
+    private removeSymlink;
+    /**
+     * Delete a symlink configuration entirely
+     */
+    deleteSymlink(id: string): Promise<SymlinkOperationResult>;
+    /**
+     * Update a symlink configuration
+     */
+    updateSymlink(id: string, updates: Partial<Omit<SymlinkConfig, 'id' | 'createdAt'>>): Promise<SymlinkOperationResult>;
+}
+/**
+ * Get or create the SymlinkManager instance
+ */
+export declare function getSymlinkManager(): Promise<SymlinkManager>;