@bhimudev/gnanai 0.4.0

package/dist/commands/knowledge-sync.js

@@ -0,0 +1,661 @@
+import { execFileSync } from 'child_process';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+import { logger } from '../utils/logger.js';
+import { validateGroupName, getGroupPath, getGroupJsonPath } from './knowledge.js';
+const GROUPS_BASE = path.join(os.homedir(), '.archai', 'knowledge', 'groups');
+const CACHE_FILES = ['.index.db', '.index.db-wal', '.index.db-shm', '.vectors.json'];
+const GITIGNORE_ENTRIES = ['.index.db', '.index.db-wal', '.index.db-shm', '.vectors.json'];
+// --- Git Utilities ---
+/**
+ * Execute a git command in the given directory.
+ * Uses execFileSync (no shell) for cross-platform safety.
+ */
+export function execGit(args, cwd, extraEnv) {
+    const result = execFileSync('git', args, {
+        cwd,
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 30000,
+        env: extraEnv ? { ...process.env, ...extraEnv } : undefined,
+    });
+    return result.trim();
+}
+/**
+ * Check if a directory is a git repository.
+ */
+export function isGitRepo(dirPath) {
+    try {
+        execGit(['rev-parse', '--is-inside-work-tree'], dirPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Ensure the .gitignore in a group directory contains all required entries.
+ */
+export async function ensureGitignore(groupPath) {
+    const gitignorePath = path.join(groupPath, '.gitignore');
+    let content = '';
+    if (await fs.pathExists(gitignorePath)) {
+        content = await fs.readFile(gitignorePath, 'utf-8');
+    }
+    const lines = content.split('\n').map(l => l.trim());
+    const missing = GITIGNORE_ENTRIES.filter(entry => !lines.includes(entry));
+    if (missing.length > 0) {
+        const suffix = (content.endsWith('\n') || content === '') ? '' : '\n';
+        const addition = missing.join('\n') + '\n';
+        await fs.writeFile(gitignorePath, content + suffix + addition);
+    }
+}
+/**
+ * Ensure git user config is set for commits in the given repo.
+ * Sets local defaults if global config is missing.
+ */
+function ensureGitUser(cwd) {
+    try {
+        execGit(['config', 'user.name'], cwd);
+    }
+    catch {
+        execGit(['config', 'user.name', 'archai-sync'], cwd);
+    }
+    try {
+        execGit(['config', 'user.email'], cwd);
+    }
+    catch {
+        execGit(['config', 'user.email', 'archai@local'], cwd);
+    }
+}
+// --- Conflict Resolution ---
+/**
+ * Extract one side of a git merge conflict from file content.
+ * Returns the content between the conflict markers for the specified side,
+ * or null if no valid conflict markers are found.
+ */
+export function extractConflictSide(content, side) {
+    const lines = content.split('\n');
+    let startIdx = -1;
+    let separatorIdx = -1;
+    let endIdx = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].startsWith('<<<<<<<')) {
+            startIdx = i;
+        }
+        else if (lines[i].startsWith('=======') && startIdx >= 0) {
+            separatorIdx = i;
+        }
+        else if (lines[i].startsWith('>>>>>>>') && separatorIdx >= 0) {
+            endIdx = i;
+            break;
+        }
+    }
+    if (startIdx < 0 || separatorIdx < 0 || endIdx < 0) {
+        return null;
+    }
+    if (side === 'ours') {
+        return lines.slice(startIdx + 1, separatorIdx).join('\n');
+    }
+    else {
+        return lines.slice(separatorIdx + 1, endIdx).join('\n');
+    }
+}
+/**
+ * Auto-resolve group.json merge conflicts by union-merging the members array.
+ * Returns true if conflict was resolved, false if it could not be auto-resolved.
+ */
+export async function resolveGroupJsonConflict(groupPath) {
+    const conflictPath = path.join(groupPath, 'group.json');
+    let content;
+    try {
+        content = await fs.readFile(conflictPath, 'utf-8');
+    }
+    catch {
+        return false;
+    }
+    if (!content.includes('<<<<<<<'))
+        return false;
+    const ours = extractConflictSide(content, 'ours');
+    const theirs = extractConflictSide(content, 'theirs');
+    if (!ours || !theirs)
+        return false;
+    try {
+        const oursJson = JSON.parse(ours);
+        const theirsJson = JSON.parse(theirs);
+        // Union merge members, deduplicate by normalized path
+        const allMembers = new Map();
+        for (const m of [...oursJson.members, ...theirsJson.members]) {
+            allMembers.set(path.resolve(m), m);
+        }
+        const resolved = {
+            ...theirsJson,
+            members: [...allMembers.values()],
+            remote: oursJson.remote || theirsJson.remote,
+        };
+        // Atomic write
+        const tmpPath = conflictPath + '.tmp.' + Date.now();
+        await fs.writeFile(tmpPath, JSON.stringify(resolved, null, 2) + '\n');
+        await fs.rename(tmpPath, conflictPath);
+        // Stage the resolution
+        execGit(['add', 'group.json'], groupPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// --- Index Invalidation ---
+/**
+ * Delete search index and vector store cache files.
+ * These are rebuilt automatically by the MCP server on next startup.
+ */
+export async function invalidateSearchIndices(groupPath) {
+    for (const file of CACHE_FILES) {
+        const filePath = path.join(groupPath, file);
+        try {
+            await fs.remove(filePath);
+        }
+        catch {
+            // ignore -- file may not exist
+        }
+    }
+}
+// --- Sync Status ---
+/**
+ * Get the git sync status of a knowledge group.
+ */
+export function getGitSyncStatus(groupPath) {
+    if (!isGitRepo(groupPath))
+        return { status: 'no-git' };
+    try {
+        execGit(['remote', 'get-url', 'origin'], groupPath);
+    }
+    catch {
+        return { status: 'no-remote' };
+    }
+    // Check for uncommitted changes
+    const statusOutput = execGit(['status', '--porcelain'], groupPath);
+    const dirty = statusOutput.length > 0;
+    // Fetch to compare (non-destructive)
+    try {
+        execGit(['fetch', 'origin', '--quiet'], groupPath);
+    }
+    catch {
+        // Offline -- can only report local state
+        return dirty ? { status: 'dirty', dirty: true } : { status: 'clean' };
+    }
+    // Count ahead/behind
+    try {
+        const counts = execGit(['rev-list', '--left-right', '--count', 'HEAD...origin/main'], groupPath);
+        const parts = counts.split(/\s+/);
+        const ahead = parseInt(parts[0], 10) || 0;
+        const behind = parseInt(parts[1], 10) || 0;
+        if (dirty)
+            return { status: 'dirty', dirty: true, ahead, behind };
+        if (ahead > 0 && behind > 0)
+            return { status: 'diverged', ahead, behind };
+        if (ahead > 0)
+            return { status: 'ahead', ahead, behind: 0 };
+        if (behind > 0)
+            return { status: 'behind', ahead: 0, behind };
+        return { status: 'clean', ahead: 0, behind: 0 };
+    }
+    catch {
+        // No commits on remote yet or other issue
+        return dirty ? { status: 'dirty', dirty: true } : { status: 'clean' };
+    }
+}
+// --- Core Sync Operation ---
+/**
+ * Perform a full sync operation on a knowledge group:
+ * stage -> commit -> pull --rebase -> push -> invalidate indices.
+ */
+export async function syncGroup(groupPath, name) {
+    // 1. Check remote is configured
+    try {
+        execGit(['remote', 'get-url', 'origin'], groupPath);
+    }
+    catch {
+        return {
+            success: false, pushed: false, pulled: false,
+            error: 'No remote configured for group "' + name + '".',
+        };
+    }
+    // 2. Stage all changes
+    execGit(['add', '-A'], groupPath);
+    // 3. Commit if there are staged changes
+    try {
+        execGit(['diff', '--cached', '--quiet'], groupPath);
+        // No error = no changes staged
+    }
+    catch {
+        // Exit code 1 = there are changes
+        ensureGitUser(groupPath);
+        const timestamp = new Date().toISOString().replace(/\.\d+Z$/, 'Z');
+        execGit(['commit', '-m', 'knowledge sync: ' + timestamp], groupPath);
+    }
+    // 4. Pull with rebase
+    let pulled = false;
+    try {
+        execGit(['pull', '--rebase', 'origin', 'main'], groupPath);
+        pulled = true;
+    }
+    catch (err) {
+        const errMsg = getErrorMessage(err);
+        if (isNetworkError(errMsg)) {
+            return {
+                success: false, pushed: false, pulled: false,
+                error: 'Sync failed: could not reach remote. Local changes preserved.',
+            };
+        }
+        if (isConflictError(errMsg)) {
+            // Try auto-resolve group.json conflicts
+            const resolved = await resolveGroupJsonConflict(groupPath);
+            if (resolved) {
+                try {
+                    execGit(['rebase', '--continue'], groupPath, {
+                        GIT_EDITOR: 'true',
+                        GIT_SEQUENCE_EDITOR: 'true',
+                    });
+                    pulled = true;
+                }
+                catch {
+                    try {
+                        execGit(['rebase', '--abort'], groupPath);
+                    }
+                    catch { /* ignore */ }
+                    return {
+                        success: false, pushed: false, pulled: false,
+                        error: 'Failed to continue rebase after conflict resolution.',
+                    };
+                }
+            }
+            else {
+                // Identify conflicting files
+                let conflictFiles = [];
+                try {
+                    const conflictOutput = execGit(['diff', '--name-only', '--diff-filter=U'], groupPath);
+                    conflictFiles = conflictOutput.split('\n').filter(Boolean);
+                }
+                catch { /* ignore */ }
+                try {
+                    execGit(['rebase', '--abort'], groupPath);
+                }
+                catch { /* ignore */ }
+                return {
+                    success: false, pushed: false, pulled: false,
+                    conflictFiles,
+                    error: 'Merge conflicts could not be auto-resolved.',
+                };
+            }
+        }
+        else {
+            return {
+                success: false, pushed: false, pulled: false,
+                error: 'Pull failed: ' + errMsg,
+            };
+        }
+    }
+    // 5. Push
+    let pushed = false;
+    try {
+        execGit(['push', 'origin', 'main'], groupPath);
+        pushed = true;
+    }
+    catch (err) {
+        const errMsg = getErrorMessage(err);
+        if (isNetworkError(errMsg)) {
+            return {
+                success: false, pushed: false, pulled,
+                error: 'Sync failed: could not reach remote. Local changes preserved.',
+            };
+        }
+        return {
+            success: false, pushed: false, pulled,
+            error: 'Push failed: ' + errMsg,
+        };
+    }
+    // 6. Invalidate search indices
+    await invalidateSearchIndices(groupPath);
+    return { success: true, pushed, pulled };
+}
+function getErrorMessage(err) {
+    if (err instanceof Error) {
+        // execFileSync errors include stderr in the message or as a property
+        const execErr = err;
+        if (execErr.stderr) {
+            return typeof execErr.stderr === 'string' ? execErr.stderr : execErr.stderr.toString();
+        }
+        return err.message;
+    }
+    return String(err);
+}
+function isNetworkError(msg) {
+    const patterns = [
+        'Could not resolve host',
+        'Connection refused',
+        'fatal: unable to access',
+        'Could not read from remote',
+        'Network is unreachable',
+        'Connection timed out',
+        'No route to host',
+    ];
+    return patterns.some(p => msg.includes(p));
+}
+function isConflictError(msg) {
+    return msg.includes('CONFLICT') || msg.includes('conflict') || msg.includes('could not apply');
+}
+// --- CLI Commands ---
+/**
+ * Add a git remote to a knowledge group for team sharing.
+ * Initializes git repo if needed, commits existing content, and pushes.
+ */
+export async function knowledgeRemote(name, url) {
+    const validation = validateGroupName(name);
+    if (!validation.valid) {
+        logger.error(validation.error);
+        process.exitCode = 1;
+        return;
+    }
+    const groupPath = getGroupPath(name);
+    const jsonPath = getGroupJsonPath(name);
+    if (!(await fs.pathExists(jsonPath))) {
+        logger.error('Knowledge group "' + name + '" does not exist.');
+        logger.info('Create it first: archai knowledge create ' + name);
+        process.exitCode = 1;
+        return;
+    }
+    // Initialize git repo if not already
+    if (!isGitRepo(groupPath)) {
+        execGit(['init'], groupPath);
+        execGit(['branch', '-M', 'main'], groupPath);
+        logger.info('Initialized git repository.');
+    }
+    // Ensure .gitignore is correct
+    await ensureGitignore(groupPath);
+    // Add remote (check if already exists)
+    try {
+        const existingUrl = execGit(['remote', 'get-url', 'origin'], groupPath);
+        if (existingUrl === url) {
+            logger.info('Remote "origin" already set to ' + url);
+        }
+        else {
+            execGit(['remote', 'set-url', 'origin', url], groupPath);
+            logger.info('Updated remote "origin" to ' + url);
+        }
+    }
+    catch {
+        execGit(['remote', 'add', 'origin', url], groupPath);
+    }
+    // Update group.json with remote URL
+    const raw = await fs.readFile(jsonPath, 'utf-8');
+    const groupData = JSON.parse(raw);
+    if (groupData.remote !== url) {
+        groupData.remote = url;
+        const tmpPath = jsonPath + '.tmp.' + Date.now();
+        await fs.writeFile(tmpPath, JSON.stringify(groupData, null, 2) + '\n');
+        await fs.rename(tmpPath, jsonPath);
+    }
+    // Ensure git user is configured
+    ensureGitUser(groupPath);
+    // Initial commit of existing entries
+    execGit(['add', '-A'], groupPath);
+    try {
+        execGit(['diff', '--cached', '--quiet'], groupPath);
+        // No changes to commit
+    }
+    catch {
+        execGit(['commit', '-m', 'Initial knowledge base'], groupPath);
+    }
+    // Push to remote
+    try {
+        execGit(['push', '-u', 'origin', 'main'], groupPath);
+        logger.success('Remote configured and knowledge pushed to ' + url);
+    }
+    catch (err) {
+        const errMsg = getErrorMessage(err);
+        if (isNetworkError(errMsg)) {
+            logger.warn('Remote configured but push failed: could not reach remote.');
+        }
+        else {
+            logger.warn('Remote configured but push failed: ' + errMsg);
+        }
+        logger.info('Run "archai knowledge sync ' + name + '" to push later.');
+    }
+}
+/**
+ * Clone an existing knowledge group from a git remote.
+ */
+export async function knowledgeCreateFrom(name, url) {
+    const validation = validateGroupName(name);
+    if (!validation.valid) {
+        logger.error(validation.error);
+        process.exitCode = 1;
+        return;
+    }
+    const groupPath = getGroupPath(name);
+    if (await fs.pathExists(groupPath)) {
+        logger.error('Knowledge group "' + name + '" already exists at ' + groupPath);
+        process.exitCode = 1;
+        return;
+    }
+    // Ensure parent directory exists
+    await fs.ensureDir(path.dirname(groupPath));
+    // Clone
+    try {
+        execFileSync('git', ['clone', url, groupPath], {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 60000,
+        });
+    }
+    catch (err) {
+        const errMsg = getErrorMessage(err);
+        logger.error('Failed to clone from ' + url + ': ' + errMsg);
+        process.exitCode = 1;
+        return;
+    }
+    // Verify cloned repo has a valid group.json
+    const jsonPath = getGroupJsonPath(name);
+    if (!(await fs.pathExists(jsonPath))) {
+        logger.error('Cloned repository does not contain a valid knowledge group (no group.json found).');
+        await fs.remove(groupPath);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const raw = await fs.readFile(jsonPath, 'utf-8');
+        JSON.parse(raw);
+    }
+    catch {
+        logger.error('Cloned repository has an invalid group.json.');
+        await fs.remove(groupPath);
+        process.exitCode = 1;
+        return;
+    }
+    logger.success('Cloned knowledge group "' + name + '" from ' + url);
+    logger.info('Path: ' + groupPath);
+    console.log('');
+    console.log(chalk.gray('  Next steps:'));
+    console.log(chalk.gray('    cd ~/your-project && archai knowledge join ' + name));
+    console.log(chalk.gray('    archai knowledge sync ' + name + '    Sync with team'));
+    console.log('');
+}
+/**
+ * Sync one or all knowledge groups with their git remotes.
+ */
+export async function knowledgeSync(name) {
+    if (name) {
+        const validation = validateGroupName(name);
+        if (!validation.valid) {
+            logger.error(validation.error);
+            process.exitCode = 1;
+            return;
+        }
+        const groupPath = getGroupPath(name);
+        const jsonPath = getGroupJsonPath(name);
+        if (!(await fs.pathExists(jsonPath))) {
+            logger.error('Knowledge group "' + name + '" does not exist.');
+            process.exitCode = 1;
+            return;
+        }
+        if (!isGitRepo(groupPath)) {
+            logger.warn('Group "' + name + '" is not a git repository. Set up a remote first:');
+            logger.info('  archai knowledge remote ' + name + ' <url>');
+            return;
+        }
+        const result = await syncGroup(groupPath, name);
+        displaySyncResult(name, result);
+        return;
+    }
+    // Sync all groups with remotes
+    if (!(await fs.pathExists(GROUPS_BASE))) {
+        logger.info('No knowledge groups found.');
+        return;
+    }
+    const entries = await fs.readdir(GROUPS_BASE, { withFileTypes: true });
+    let syncedCount = 0;
+    let skippedCount = 0;
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const jsonPath = getGroupJsonPath(entry.name);
+        if (!(await fs.pathExists(jsonPath)))
+            continue;
+        const groupPath = getGroupPath(entry.name);
+        if (!isGitRepo(groupPath)) {
+            skippedCount++;
+            continue;
+        }
+        try {
+            execGit(['remote', 'get-url', 'origin'], groupPath);
+        }
+        catch {
+            skippedCount++;
+            continue;
+        }
+        const result = await syncGroup(groupPath, entry.name);
+        displaySyncResult(entry.name, result);
+        syncedCount++;
+    }
+    if (syncedCount === 0 && skippedCount > 0) {
+        logger.info('No groups with remotes found. ' + skippedCount + ' local-only group(s) skipped.');
+    }
+    else if (syncedCount === 0) {
+        logger.info('No knowledge groups found to sync.');
+    }
+}
+/**
+ * Display detailed information about a knowledge group.
+ */
+export async function knowledgeInfo(name) {
+    const validation = validateGroupName(name);
+    if (!validation.valid) {
+        logger.error(validation.error);
+        process.exitCode = 1;
+        return;
+    }
+    const groupPath = getGroupPath(name);
+    const jsonPath = getGroupJsonPath(name);
+    if (!(await fs.pathExists(jsonPath))) {
+        logger.error('Knowledge group "' + name + '" does not exist.');
+        process.exitCode = 1;
+        return;
+    }
+    const raw = await fs.readFile(jsonPath, 'utf-8');
+    const groupData = JSON.parse(raw);
+    // Count entries per category
+    const categories = ['decisions', 'patterns', 'constraints', 'learnings', 'context'];
+    const categoryCounts = {};
+    let totalEntries = 0;
+    for (const cat of categories) {
+        const catDir = path.join(groupPath, cat);
+        let count = 0;
+        if (await fs.pathExists(catDir)) {
+            const files = await fs.readdir(catDir);
+            count = files.filter(f => f.endsWith('.md') && !f.startsWith('.')).length;
+        }
+        categoryCounts[cat] = count;
+        totalEntries += count;
+    }
+    // Get sync status
+    const syncStatus = getGitSyncStatus(groupPath);
+    // Get last commit date (proxy for last sync time)
+    let lastSyncTime = 'never';
+    if (isGitRepo(groupPath)) {
+        try {
+            lastSyncTime = execGit(['log', '-1', '--format=%ci'], groupPath);
+        }
+        catch {
+            lastSyncTime = 'no commits';
+        }
+    }
+    // Display
+    console.log('');
+    logger.section('Knowledge Group: ' + name);
+    console.log('');
+    console.log('  ' + chalk.gray('Name:       ') + chalk.white(groupData.name));
+    console.log('  ' + chalk.gray('Created:    ') + chalk.white(groupData.created));
+    console.log('  ' + chalk.gray('Members:    ') + chalk.white(String(groupData.members.length)));
+    if (groupData.members.length > 0) {
+        for (const member of groupData.members) {
+            console.log('  ' + chalk.gray('            ') + chalk.gray(member));
+        }
+    }
+    console.log('  ' + chalk.gray('Remote:     ') + (groupData.remote ? chalk.cyan(groupData.remote) : chalk.gray('not configured')));
+    console.log('  ' + chalk.gray('Last sync:  ') + chalk.white(lastSyncTime));
+    console.log('');
+    // Entries by category
+    console.log('  ' + chalk.gray('Entries:    ') + chalk.white(String(totalEntries) + ' total'));
+    for (const cat of categories) {
+        if (categoryCounts[cat] > 0) {
+            console.log('  ' + chalk.gray('            ') + chalk.gray(cat + ': ') + chalk.white(String(categoryCounts[cat])));
+        }
+    }
+    console.log('');
+    // Sync status
+    const statusLabel = formatSyncStatus(syncStatus);
+    console.log('  ' + chalk.gray('Sync:       ') + statusLabel);
+    console.log('');
+}
+function formatSyncStatus(status) {
+    switch (status.status) {
+        case 'no-git':
+            return chalk.gray('not a git repo');
+        case 'no-remote':
+            return chalk.gray('no remote configured');
+        case 'clean':
+            return chalk.green('up to date');
+        case 'dirty':
+            return chalk.yellow('uncommitted changes');
+        case 'ahead':
+            return chalk.yellow('ahead by ' + status.ahead + ' commit(s)');
+        case 'behind':
+            return chalk.yellow('behind by ' + status.behind + ' commit(s)');
+        case 'diverged':
+            return chalk.red('diverged (ahead ' + status.ahead + ', behind ' + status.behind + ')');
+        default:
+            return chalk.gray('unknown');
+    }
+}
+function displaySyncResult(name, result) {
+    if (result.success) {
+        logger.success('Synced "' + name + '"');
+    }
+    else {
+        if (result.conflictFiles && result.conflictFiles.length > 0) {
+            logger.warn('Sync of "' + name + '" failed: ' + result.error);
+            logger.info('Conflicting files:');
+            for (const f of result.conflictFiles) {
+                console.log('    ' + chalk.yellow(f));
+            }
+        }
+        else {
+            logger.warn('Sync of "' + name + '": ' + result.error);
+        }
+    }
+}
+//# sourceMappingURL=knowledge-sync.js.map