@rglabs/butterfly 2.0.1

package/dist/utils/auth.d.ts

@@ -0,0 +1,4 @@
+import { AuthConfig } from '../types/index.js';
+export declare function saveAuthConfig(config: AuthConfig): Promise<void>;
+export declare function loadAuthConfig(): Promise<AuthConfig | null>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/utils/auth.js

@@ -0,0 +1,22 @@
+import { join } from 'path';
+import { promises as fs } from 'fs';
+const CONFIG_DIR = '.butterfly';
+const CONFIG_FILE = 'config.json';
+function getConfigPath() {
+    return join(process.cwd(), CONFIG_DIR, CONFIG_FILE);
+}
+export async function saveAuthConfig(config) {
+    const configDir = join(process.cwd(), CONFIG_DIR);
+    await fs.mkdir(configDir, { recursive: true });
+    await fs.writeFile(getConfigPath(), JSON.stringify(config, null, 2));
+}
+export async function loadAuthConfig() {
+    try {
+        const data = await fs.readFile(getConfigPath(), 'utf-8');
+        return JSON.parse(data);
+    }
+    catch (error) {
+        return null;
+    }
+}
+//# sourceMappingURL=auth.js.map

package/dist/utils/bfySplitter.d.ts

@@ -0,0 +1,12 @@
+export declare function hasSplitMarkers(content: string): boolean;
+export declare function hasIncludeMarkers(content: string): boolean;
+export declare function isSplitFolder(folderPath: string): Promise<boolean>;
+export declare function splitBfyFile(filePath: string): Promise<{
+    wasSplit: boolean;
+    error?: string;
+}>;
+export declare function mergeBfyFile(filePath: string): Promise<string>;
+export declare function smartReadBfyContent(bfyPath: string): Promise<string>;
+export declare function isInsidePartsFolder(filePath: string): boolean;
+export declare function getContainerPathFromPartFile(partFilePath: string): string | null;
+//# sourceMappingURL=bfySplitter.d.ts.map

package/dist/utils/bfySplitter.js

@@ -0,0 +1,151 @@
+import { promises as fs } from 'fs';
+import { join, dirname, basename } from 'path';
+const PART_START_REGEX = /\{#\s*---\s*part:\s*([a-zA-Z0-9_-]+)\s*---\s*#\}/g;
+const PART_END_REGEX = /\{#\s*---\s*endpart\s*---\s*#\}/g;
+const INCLUDE_MARKER_REGEX = /\{#\s*---\s*include:\s*([a-zA-Z0-9_-]+)\s*---\s*#\}/g;
+export function hasSplitMarkers(content) {
+    const hasStart = new RegExp(PART_START_REGEX.source).test(content);
+    const hasEnd = new RegExp(PART_END_REGEX.source).test(content);
+    return hasStart && hasEnd;
+}
+export function hasIncludeMarkers(content) {
+    return new RegExp(INCLUDE_MARKER_REGEX.source).test(content);
+}
+export async function isSplitFolder(folderPath) {
+    try {
+        const stats = await fs.stat(folderPath);
+        if (!stats.isDirectory())
+            return false;
+        const files = await fs.readdir(folderPath);
+        return files.some(f => f.endsWith('.bfy'));
+    }
+    catch {
+        return false;
+    }
+}
+function parseParts(content) {
+    const parts = [];
+    let containerContent = content;
+    const partStartRegex = new RegExp(PART_START_REGEX.source, 'g');
+    const partEndRegex = new RegExp(PART_END_REGEX.source, 'g');
+    const starts = [];
+    const ends = [];
+    let match;
+    while ((match = partStartRegex.exec(content)) !== null) {
+        starts.push({ index: match.index, name: match[1], fullMatch: match[0] });
+    }
+    while ((match = partEndRegex.exec(content)) !== null) {
+        ends.push({ index: match.index, fullMatch: match[0] });
+    }
+    if (starts.length === 0 || starts.length !== ends.length) {
+        return null;
+    }
+    const partsToExtract = [];
+    for (let i = 0; i < starts.length; i++) {
+        const start = starts[i];
+        const end = ends[i];
+        if (end.index <= start.index) {
+            return null;
+        }
+        const partContentStart = start.index + start.fullMatch.length;
+        const partContentEnd = end.index;
+        const partContent = content.substring(partContentStart, partContentEnd).trim();
+        parts.push({ name: start.name, content: partContent });
+        partsToExtract.push({ start, end, partContent });
+    }
+    for (let i = partsToExtract.length - 1; i >= 0; i--) {
+        const { start, end } = partsToExtract[i];
+        const fullPartEnd = end.index + end.fullMatch.length;
+        const includeMarker = `{# --- include: ${start.name} --- #}`;
+        containerContent = containerContent.substring(0, start.index) + includeMarker + containerContent.substring(fullPartEnd);
+    }
+    return { parts, containerContent };
+}
+export async function splitBfyFile(filePath) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        if (!hasSplitMarkers(content)) {
+            return { wasSplit: false };
+        }
+        const parsed = parseParts(content);
+        if (!parsed) {
+            return { wasSplit: false, error: 'Unbalanced or invalid part markers' };
+        }
+        const { parts, containerContent } = parsed;
+        const names = parts.map(p => p.name);
+        const duplicates = names.filter((n, i) => names.indexOf(n) !== i);
+        if (duplicates.length > 0) {
+            return { wasSplit: false, error: `Duplicate part names: ${duplicates.join(', ')}` };
+        }
+        const fileName = basename(filePath, '.bfy');
+        const dirPath = dirname(filePath);
+        const partsFolder = join(dirPath, fileName);
+        await fs.mkdir(partsFolder, { recursive: true });
+        for (const part of parts) {
+            const partFile = join(partsFolder, `${part.name}.bfy`);
+            await fs.writeFile(partFile, part.content);
+        }
+        await fs.writeFile(filePath, containerContent);
+        return { wasSplit: true };
+    }
+    catch (error) {
+        return { wasSplit: false, error: String(error) };
+    }
+}
+export async function mergeBfyFile(filePath) {
+    const content = await fs.readFile(filePath, 'utf-8');
+    if (!hasIncludeMarkers(content)) {
+        return content;
+    }
+    const fileName = basename(filePath, '.bfy');
+    const dirPath = dirname(filePath);
+    const partsFolder = join(dirPath, fileName);
+    if (!await isSplitFolder(partsFolder)) {
+        return content;
+    }
+    let mergedContent = content;
+    const includeRegex = new RegExp(INCLUDE_MARKER_REGEX.source, 'g');
+    const includes = [];
+    let match;
+    while ((match = includeRegex.exec(content)) !== null) {
+        includes.push({ fullMatch: match[0], name: match[1] });
+    }
+    for (const inc of includes) {
+        const partFile = join(partsFolder, `${inc.name}.bfy`);
+        try {
+            const partContent = await fs.readFile(partFile, 'utf-8');
+            const fullPart = `{# --- part: ${inc.name} --- #}\n${partContent}\n{# --- endpart --- #}`;
+            mergedContent = mergedContent.replace(inc.fullMatch, fullPart);
+        }
+        catch {
+            console.error(`Warning: Part file not found: ${partFile}`);
+        }
+    }
+    return mergedContent;
+}
+export async function smartReadBfyContent(bfyPath) {
+    const content = await fs.readFile(bfyPath, 'utf-8');
+    if (hasIncludeMarkers(content)) {
+        return mergeBfyFile(bfyPath);
+    }
+    return content;
+}
+export function isInsidePartsFolder(filePath) {
+    const parts = filePath.split('/');
+    for (let i = 0; i < parts.length - 1; i++) {
+        const folderName = parts[i];
+        if (i > 0 && !folderName.includes('.')) {
+            if (filePath.endsWith('.bfy')) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function getContainerPathFromPartFile(partFilePath) {
+    const dirPath = dirname(partFilePath);
+    const folderName = basename(dirPath);
+    const parentDir = dirname(dirPath);
+    return join(parentDir, `${folderName}.bfy`);
+}
+//# sourceMappingURL=bfySplitter.js.map

package/dist/utils/docs.d.ts

@@ -0,0 +1,16 @@
+export declare function checkDocsStatus(): Promise<{
+    needsUpdate: boolean;
+    sourceExists: boolean;
+    targetExists: boolean;
+    filesToUpdate: string[];
+}>;
+export declare function updateDocs(): Promise<boolean>;
+export declare function checkAndPromptDocsUpdate(): Promise<void>;
+export declare function checkAndPromptClaudeMdUpdate(): Promise<void>;
+export declare function syncDocs(): Promise<{
+    success: boolean;
+    syncedFiles: string[];
+    error?: string;
+}>;
+export declare function copyDocs(): Promise<void>;
+//# sourceMappingURL=docs.d.ts.map

package/dist/utils/docs.js

@@ -0,0 +1,186 @@
+import { join, dirname } from 'path';
+import { promises as fs } from 'fs';
+import { fileURLToPath } from 'url';
+import { createHash } from 'crypto';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export async function checkDocsStatus() {
+    const packageDocsDir = join(__dirname, '..', '..', 'docs');
+    const packageCommandsDir = join(__dirname, '..', '..', '.claude', 'commands');
+    const targetDocsDir = join(process.cwd(), 'docs');
+    const targetCommandsDir = join(process.cwd(), '.claude', 'commands');
+    const targetClaudeMd = join(process.cwd(), 'CLAUDE.md');
+    let sourceExists = false;
+    let targetExists = false;
+    const filesToUpdate = [];
+    try {
+        await fs.access(packageDocsDir);
+        sourceExists = true;
+    }
+    catch {
+        return { needsUpdate: false, sourceExists: false, targetExists: false, filesToUpdate: [] };
+    }
+    try {
+        await fs.access(targetDocsDir);
+        targetExists = true;
+    }
+    catch {
+    }
+    const packageClaudeMd = join(packageDocsDir, 'CLAUDE.md');
+    try {
+        const sourceContent = await fs.readFile(packageClaudeMd, 'utf-8');
+        const sourceHash = createHash('md5').update(sourceContent).digest('hex');
+        try {
+            const targetContent = await fs.readFile(targetClaudeMd, 'utf-8');
+            const targetHash = createHash('md5').update(targetContent).digest('hex');
+            if (sourceHash !== targetHash) {
+                filesToUpdate.push('CLAUDE.md');
+            }
+        }
+        catch {
+            filesToUpdate.push('CLAUDE.md');
+        }
+    }
+    catch {
+    }
+    await checkDirectoryForUpdates(packageDocsDir, targetDocsDir, filesToUpdate, 'docs');
+    try {
+        await fs.access(packageCommandsDir);
+        await checkDirectoryForUpdates(packageCommandsDir, targetCommandsDir, filesToUpdate, '.claude/commands');
+    }
+    catch {
+    }
+    return {
+        needsUpdate: filesToUpdate.length > 0,
+        sourceExists,
+        targetExists,
+        filesToUpdate
+    };
+}
+async function checkDirectoryForUpdates(sourceDir, targetDir, filesToUpdate, relativePath) {
+    try {
+        const files = await fs.readdir(sourceDir, { withFileTypes: true });
+        for (const file of files) {
+            const sourcePath = join(sourceDir, file.name);
+            const targetPath = join(targetDir, file.name);
+            const relPath = join(relativePath, file.name);
+            if (file.isFile()) {
+                if (file.name === 'PROJECT_SPECIFIC.md') {
+                    try {
+                        await fs.access(targetPath);
+                        continue;
+                    }
+                    catch {
+                    }
+                }
+                try {
+                    const sourceContent = await fs.readFile(sourcePath, 'utf-8');
+                    const sourceHash = createHash('md5').update(sourceContent).digest('hex');
+                    try {
+                        const targetContent = await fs.readFile(targetPath, 'utf-8');
+                        const targetHash = createHash('md5').update(targetContent).digest('hex');
+                        if (sourceHash !== targetHash) {
+                            filesToUpdate.push(relPath);
+                        }
+                    }
+                    catch {
+                        filesToUpdate.push(relPath);
+                    }
+                }
+                catch {
+                }
+            }
+            else if (file.isDirectory()) {
+                await checkDirectoryForUpdates(sourcePath, targetPath, filesToUpdate, relPath);
+            }
+        }
+    }
+    catch {
+    }
+}
+export async function updateDocs() {
+    const result = await syncDocs();
+    return result.success;
+}
+export async function checkAndPromptDocsUpdate() {
+    const status = await checkDocsStatus();
+    if (!status.needsUpdate) {
+        return;
+    }
+    const fileCount = status.filesToUpdate.length;
+    const fileList = status.filesToUpdate.join(', ');
+    console.log(`\x1b[33mUpdating ${fileCount} doc file(s): ${fileList}...\x1b[0m`);
+    const success = await updateDocs();
+    if (success) {
+        console.log(`\x1b[32m✓ Documentation updated successfully.\x1b[0m\n`);
+    }
+    else {
+        console.log(`\x1b[31m✗ Failed to update documentation.\x1b[0m\n`);
+    }
+}
+export async function checkAndPromptClaudeMdUpdate() {
+    return checkAndPromptDocsUpdate();
+}
+export async function syncDocs() {
+    const packageDocsDir = join(__dirname, '..', '..', 'docs');
+    const packageCommandsDir = join(__dirname, '..', '..', '.claude', 'commands');
+    const targetDocsDir = join(process.cwd(), 'docs');
+    const targetCommandsDir = join(process.cwd(), '.claude', 'commands');
+    const packageClaudeMd = join(packageDocsDir, 'CLAUDE.md');
+    const targetClaudeMd = join(process.cwd(), 'CLAUDE.md');
+    const syncedFiles = [];
+    try {
+        await fs.access(packageDocsDir);
+        try {
+            await fs.copyFile(packageClaudeMd, targetClaudeMd);
+            syncedFiles.push('CLAUDE.md');
+        }
+        catch {
+        }
+        await fs.mkdir(targetDocsDir, { recursive: true });
+        await syncDirectory(packageDocsDir, targetDocsDir, syncedFiles, 'docs');
+        try {
+            await fs.access(packageCommandsDir);
+            await fs.mkdir(targetCommandsDir, { recursive: true });
+            await syncDirectory(packageCommandsDir, targetCommandsDir, syncedFiles, '.claude/commands');
+        }
+        catch {
+        }
+        return { success: true, syncedFiles };
+    }
+    catch (error) {
+        return {
+            success: false,
+            syncedFiles,
+            error: error instanceof Error ? error.message : 'Unknown error'
+        };
+    }
+}
+async function syncDirectory(source, target, syncedFiles, relativePath) {
+    await fs.mkdir(target, { recursive: true });
+    const files = await fs.readdir(source, { withFileTypes: true });
+    for (const file of files) {
+        const sourcePath = join(source, file.name);
+        const targetPath = join(target, file.name);
+        const relPath = join(relativePath, file.name);
+        if (file.isFile()) {
+            if (file.name === 'PROJECT_SPECIFIC.md') {
+                try {
+                    await fs.access(targetPath);
+                    continue;
+                }
+                catch {
+                }
+            }
+            await fs.copyFile(sourcePath, targetPath);
+            syncedFiles.push(relPath);
+        }
+        else if (file.isDirectory()) {
+            await syncDirectory(sourcePath, targetPath, syncedFiles, relPath);
+        }
+    }
+}
+export async function copyDocs() {
+    await syncDocs();
+}
+//# sourceMappingURL=docs.js.map

package/dist/utils/errorLogger.d.ts

@@ -0,0 +1,6 @@
+export declare class ErrorLogger {
+    static logError(error: string): Promise<void>;
+    static clearErrorLog(): Promise<void>;
+    static getErrorLogPath(): Promise<string>;
+}
+//# sourceMappingURL=errorLogger.d.ts.map

package/dist/utils/errorLogger.js

@@ -0,0 +1,29 @@
+import { promises as fs } from 'fs';
+const ERROR_LOG_PATH = '.butterfly/error_log.txt';
+export class ErrorLogger {
+    static async logError(error) {
+        try {
+            const timestamp = new Date().toISOString();
+            const logEntry = `[${timestamp}] ${error}\n`;
+            await fs.mkdir('.butterfly', { recursive: true });
+            await fs.appendFile(ERROR_LOG_PATH, logEntry, 'utf-8');
+        }
+        catch (logErr) {
+            console.error('Failed to log error:', logErr);
+            console.error('Original error:', error);
+        }
+    }
+    static async clearErrorLog() {
+        try {
+            await fs.mkdir('.butterfly', { recursive: true });
+            await fs.writeFile(ERROR_LOG_PATH, '', 'utf-8');
+        }
+        catch (err) {
+            console.warn('Failed to clear error log:', err);
+        }
+    }
+    static async getErrorLogPath() {
+        return ERROR_LOG_PATH;
+    }
+}
+//# sourceMappingURL=errorLogger.js.map

package/dist/utils/files.d.ts

@@ -0,0 +1,14 @@
+export declare function cleanupDirectory(dirPath: string): Promise<void>;
+export declare function saveResource(outputPath: string, resourceType: string, resourceName: string, data: any): Promise<void>;
+export declare function saveAiTask(outputPath: string, aiTask: any): Promise<void>;
+export declare function restoreTableRecordFromFiles(recordDir: string, tableName: string, recordData: any): Promise<any>;
+export declare function restorePageFromFiles(pageDir: string, pageData: any): Promise<any>;
+export declare function restoreAiTaskFromFiles(taskDir: string, taskData: any): Promise<any>;
+export declare function restoreFieldsFromFiles(baseDir: string, data: any): Promise<any>;
+export declare function saveObjectWithSpecs(outputPath: string, tableName: string, objectData: any, specs: any[]): Promise<void>;
+export declare function saveTableRecord(outputPath: string, tableName: string, recordData: any, specs?: any[]): Promise<void>;
+export declare function savePageData(outputPath: string, pageData: any): Promise<void>;
+export declare function saveReportData(outputPath: string, reportData: any, specs: any[], queries: any[], categories: any[]): Promise<void>;
+export declare function saveStateMachineData(outputPath: string, stateMachine: any, states: any[], roles: any[], transitions: any[], transitionSpecs: any[], actions: any[], actionSpecs: any[], transitionActions: any[]): Promise<void>;
+export declare function saveWorkflowData(outputPath: string, workflow: any, versions: any[], nodes: any[], connections: any[]): Promise<void>;
+//# sourceMappingURL=files.d.ts.map