brainctl 0.1.2 → 0.1.4

package/dist/services/memory-write-service.js

@@ -0,0 +1,56 @@
+import { lstat, mkdir, realpath, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { MemoryPathError } from '../errors.js';
+export function createMemoryWriteService() {
+    return {
+        async execute(request) {
+            const cwd = request.cwd ?? process.cwd();
+            const targetPath = path.resolve(cwd, request.filePath);
+            const workspaceRoot = await realpath(cwd);
+            const resolvedTargetPath = await resolvePathForWrite(targetPath);
+            if (!isWithinDirectory(workspaceRoot, resolvedTargetPath)) {
+                throw new MemoryPathError('Memory files must stay within the workspace root.');
+            }
+            await mkdir(path.dirname(targetPath), { recursive: true });
+            await writeFile(targetPath, request.content, 'utf8');
+            return { filePath: targetPath };
+        }
+    };
+}
+async function resolvePathForWrite(targetPath) {
+    const existingPath = await findNearestExistingPath(targetPath);
+    const resolvedExistingPath = await realpath(existingPath);
+    if (existingPath === targetPath) {
+        return resolvedExistingPath;
+    }
+    return path.resolve(resolvedExistingPath, path.relative(existingPath, targetPath));
+}
+async function findNearestExistingPath(targetPath) {
+    let currentPath = targetPath;
+    while (true) {
+        try {
+            await lstat(currentPath);
+            return currentPath;
+        }
+        catch (error) {
+            if (!isMissingPathError(error)) {
+                throw error;
+            }
+        }
+        const parentPath = path.dirname(currentPath);
+        if (parentPath === currentPath) {
+            throw new MemoryPathError(`Could not resolve filesystem path for ${targetPath}.`);
+        }
+        currentPath = parentPath;
+    }
+}
+function isWithinDirectory(parentDirectory, targetPath) {
+    const relativePath = path.relative(parentDirectory, targetPath);
+    if (relativePath === '') {
+        return true;
+    }
+    return !relativePath.startsWith(`..${path.sep}`) && relativePath !== '..' && !path.isAbsolute(relativePath);
+}
+function isMissingPathError(error) {
+    return error instanceof Error && 'code' in error && error.code === 'ENOENT';
+}

package/dist/services/profile-service.d.ts

@@ -0,0 +1,30 @@
+import type { BrainctlMetaConfig, ProfileConfig } from '../types.js';
+export interface ProfileService {
+    list(options?: {
+        cwd?: string;
+    }): Promise<{
+        profiles: string[];
+        activeProfile: string | null;
+    }>;
+    get(options: {
+        cwd?: string;
+        name: string;
+    }): Promise<ProfileConfig>;
+    create(options: {
+        cwd?: string;
+        name: string;
+        description?: string;
+    }): Promise<{
+        profilePath: string;
+    }>;
+    use(options: {
+        cwd?: string;
+        name: string;
+    }): Promise<{
+        previousProfile: string | null;
+    }>;
+    getMetaConfig(options?: {
+        cwd?: string;
+    }): Promise<BrainctlMetaConfig>;
+}
+export declare function createProfileService(): ProfileService;

package/dist/services/profile-service.js

@@ -0,0 +1,190 @@
+import { readdir, readFile, writeFile, mkdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import YAML from 'yaml';
+import { ProfileError, ProfileNotFoundError } from '../errors.js';
+const BRAINCTL_DIR = '.brainctl';
+const PROFILES_DIR = '.brainctl/profiles';
+const META_CONFIG = '.brainctl/config.yaml';
+export function createProfileService() {
+    return {
+        async list(options = {}) {
+            const cwd = options.cwd ?? process.cwd();
+            const profilesDir = path.join(cwd, PROFILES_DIR);
+            let files = [];
+            try {
+                const entries = await readdir(profilesDir);
+                files = entries
+                    .filter((f) => f.endsWith('.yaml'))
+                    .map((f) => f.replace(/\.yaml$/, ''))
+                    .sort();
+            }
+            catch {
+                // No profiles directory yet
+            }
+            const meta = await loadMetaConfig(cwd);
+            return {
+                profiles: files,
+                activeProfile: meta.active_profile || null,
+            };
+        },
+        async get(options) {
+            const cwd = options.cwd ?? process.cwd();
+            const profilePath = path.join(cwd, PROFILES_DIR, `${options.name}.yaml`);
+            let source;
+            try {
+                source = await readFile(profilePath, 'utf8');
+            }
+            catch {
+                throw new ProfileNotFoundError(`Profile "${options.name}" not found at ${profilePath}`);
+            }
+            return parseProfile(source, options.name);
+        },
+        async create(options) {
+            const cwd = options.cwd ?? process.cwd();
+            const profilesDir = path.join(cwd, PROFILES_DIR);
+            const profilePath = path.join(profilesDir, `${options.name}.yaml`);
+            if (await pathExists(profilePath)) {
+                throw new ProfileError(`Profile "${options.name}" already exists.`);
+            }
+            const scaffold = {
+                name: options.name,
+                description: options.description ?? '',
+                skills: {
+                    example: {
+                        description: 'Example skill',
+                        prompt: 'Describe what this skill does...',
+                    },
+                },
+                mcps: {},
+                memory: {
+                    paths: ['./memory'],
+                },
+            };
+            await mkdir(profilesDir, { recursive: true });
+            await writeFile(profilePath, YAML.stringify(scaffold), 'utf8');
+            return { profilePath };
+        },
+        async use(options) {
+            const cwd = options.cwd ?? process.cwd();
+            // Validate profile exists
+            const profilePath = path.join(cwd, PROFILES_DIR, `${options.name}.yaml`);
+            if (!(await pathExists(profilePath))) {
+                throw new ProfileNotFoundError(`Profile "${options.name}" not found.`);
+            }
+            const meta = await loadMetaConfig(cwd);
+            const previousProfile = meta.active_profile || null;
+            meta.active_profile = options.name;
+            const metaPath = path.join(cwd, META_CONFIG);
+            await mkdir(path.dirname(metaPath), { recursive: true });
+            await writeFile(metaPath, YAML.stringify(meta), 'utf8');
+            return { previousProfile };
+        },
+        async getMetaConfig(options = {}) {
+            const cwd = options.cwd ?? process.cwd();
+            return loadMetaConfig(cwd);
+        },
+    };
+}
+async function loadMetaConfig(cwd) {
+    const metaPath = path.join(cwd, META_CONFIG);
+    try {
+        const source = await readFile(metaPath, 'utf8');
+        const parsed = YAML.parse(source) ?? {};
+        return {
+            active_profile: typeof parsed.active_profile === 'string' ? parsed.active_profile : '',
+            agents: Array.isArray(parsed.agents) ? parsed.agents : ['claude', 'codex'],
+        };
+    }
+    catch {
+        return { active_profile: '', agents: ['claude', 'codex', 'gemini'] };
+    }
+}
+function parseProfile(source, name) {
+    let parsed;
+    try {
+        parsed = YAML.parse(source) ?? {};
+    }
+    catch {
+        throw new ProfileError(`Profile "${name}" has invalid YAML.`);
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new ProfileError(`Profile "${name}" has invalid structure.`);
+    }
+    const data = parsed;
+    const skills = {};
+    if (data.skills && typeof data.skills === 'object' && !Array.isArray(data.skills)) {
+        for (const [key, value] of Object.entries(data.skills)) {
+            if (value && typeof value === 'object' && !Array.isArray(value)) {
+                const s = value;
+                if (typeof s.prompt === 'string') {
+                    skills[key] = {
+                        prompt: s.prompt,
+                        description: typeof s.description === 'string' ? s.description : undefined,
+                    };
+                }
+            }
+        }
+    }
+    const mcps = {};
+    if (data.mcps && typeof data.mcps === 'object' && !Array.isArray(data.mcps)) {
+        for (const [key, value] of Object.entries(data.mcps)) {
+            if (value && typeof value === 'object' && !Array.isArray(value)) {
+                const m = value;
+                if (m.type === 'npm' && typeof m.package === 'string') {
+                    mcps[key] = {
+                        type: 'npm',
+                        package: m.package,
+                        env: parseEnv(m.env),
+                    };
+                }
+                else if (m.type === 'bundled' && typeof m.command === 'string') {
+                    mcps[key] = {
+                        type: 'bundled',
+                        path: typeof m.path === 'string' ? m.path : '.',
+                        install: typeof m.install === 'string' ? m.install : undefined,
+                        command: m.command,
+                        args: Array.isArray(m.args) ? m.args.map(String) : undefined,
+                        env: parseEnv(m.env),
+                    };
+                }
+            }
+        }
+    }
+    const memoryPaths = [];
+    if (data.memory && typeof data.memory === 'object' && !Array.isArray(data.memory)) {
+        const mem = data.memory;
+        if (Array.isArray(mem.paths)) {
+            for (const p of mem.paths) {
+                if (typeof p === 'string') {
+                    memoryPaths.push(p);
+                }
+            }
+        }
+    }
+    return {
+        name: typeof data.name === 'string' ? data.name : name,
+        description: typeof data.description === 'string' ? data.description : undefined,
+        skills,
+        mcps,
+        memory: { paths: memoryPaths },
+    };
+}
+function parseEnv(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+        result[k] = String(v);
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+async function pathExists(targetPath) {
+    try {
+        await stat(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/services/run-service.d.ts

@@ -1,7 +1,11 @@
 import type { ExecutorResolver } from '../executor/resolver.js';
 import type { ExecutionStep, ExecutionTrace, RunRequest } from '../types.js';
 export interface RunService {
-    execute(request: RunRequest): Promise<ExecutionTrace>;
+    execute(request: RunRequest, options?: RunServiceExecuteOptions): Promise<ExecutionTrace>;
+}
+export interface RunServiceExecuteOptions {
+    onOutputChunk?: (chunk: string) => void;
+    streamOutput?: boolean;
 }
 interface RunServiceDependencies {
     resolver?: ExecutorResolver;

package/dist/services/run-service.js

@@ -9,7 +9,7 @@ import { createExecutorResolver } from '../executor/resolver.js';
 export function createRunService(dependencies = {}) {
     const resolver = dependencies.resolver ?? createExecutorResolver();
     return {
-        async execute(request) {
+        async execute(request, options = {}) {
             const cwd = request.cwd ?? process.cwd();
             const config = await loadConfig({ cwd });
             const memory = await loadMemory({ paths: config.memory.paths });
@@ -30,7 +30,8 @@ export function createRunService(dependencies = {}) {
                     fallbackUsed = true;
                 }
                 const result = await executor.instance.run(context, {
-                    streamOutput: true
+                    streamOutput: options.streamOutput ?? true,
+                    onOutputChunk: options.onOutputChunk
                 });
                 previousOutput = result.output;
                 results.push({

package/dist/services/sync/agent-writer.d.ts

@@ -0,0 +1,18 @@
+import type { McpServerConfig } from '../../types.js';
+export interface AgentWriteOptions {
+    mcpServers: Record<string, McpServerConfig>;
+    cwd: string;
+}
+export interface AgentWriteResult {
+    configPath: string;
+    backedUpTo: string | null;
+}
+export interface AgentConfigWriter {
+    write(options: AgentWriteOptions): Promise<AgentWriteResult>;
+    restore(options: {
+        cwd: string;
+    }): Promise<{
+        restoredFrom: string;
+    }>;
+}
+export declare function formatTimestamp(): string;

package/dist/services/sync/agent-writer.js

@@ -0,0 +1,5 @@
+export function formatTimestamp() {
+    const now = new Date();
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+}

package/dist/services/sync/claude-writer.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfigWriter } from './agent-writer.js';
+export declare function createClaudeWriter(): AgentConfigWriter;

package/dist/services/sync/claude-writer.js

@@ -0,0 +1,83 @@
+import { copyFile, readdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { SyncError } from '../../errors.js';
+import { formatTimestamp } from './agent-writer.js';
+export function createClaudeWriter() {
+    return {
+        async write(options) {
+            const configPath = path.join(homedir(), '.claude.json');
+            let existing = {};
+            let backedUpTo = null;
+            // Read existing config
+            try {
+                const source = await readFile(configPath, 'utf8');
+                existing = JSON.parse(source);
+            }
+            catch {
+                // No existing config, start fresh
+            }
+            // Backup if file exists
+            if (Object.keys(existing).length > 0) {
+                const backupPath = `${configPath}.bak.${formatTimestamp()}`;
+                await copyFile(configPath, backupPath);
+                backedUpTo = backupPath;
+            }
+            // Build mcpServers for this project
+            const mcpServers = {};
+            for (const [name, config] of Object.entries(options.mcpServers)) {
+                mcpServers[name] = toClaudeFormat(config);
+            }
+            // Always include brainctl itself
+            mcpServers['brainctl'] = {
+                type: 'stdio',
+                command: 'npx',
+                args: ['-y', 'brainctl', 'mcp'],
+            };
+            // Merge into existing config (preserve other projects)
+            const projects = (existing.projects ?? {});
+            const projectConfig = projects[options.cwd] ?? {};
+            projectConfig.mcpServers = mcpServers;
+            projects[options.cwd] = projectConfig;
+            existing.projects = projects;
+            // Atomic write: write to temp, then rename
+            const tmpPath = `${configPath}.tmp.${Date.now()}`;
+            await writeFile(tmpPath, JSON.stringify(existing, null, 2) + '\n', 'utf8');
+            await rename(tmpPath, configPath);
+            return { configPath, backedUpTo };
+        },
+        async restore(options) {
+            const configPath = path.join(homedir(), '.claude.json');
+            const dir = path.dirname(configPath);
+            const base = path.basename(configPath);
+            const entries = await readdir(dir);
+            const backups = entries
+                .filter((f) => f.startsWith(`${base}.bak.`))
+                .sort()
+                .reverse();
+            if (backups.length === 0) {
+                throw new SyncError('No Claude config backup found.');
+            }
+            const latestBackup = path.join(dir, backups[0]);
+            await copyFile(latestBackup, configPath);
+            return { restoredFrom: latestBackup };
+        },
+    };
+}
+function toClaudeFormat(config) {
+    if (config.type === 'npm') {
+        return {
+            type: 'stdio',
+            command: 'npx',
+            args: ['-y', config.package],
+            ...(config.env ? { env: config.env } : {}),
+        };
+    }
+    // bundled
+    return {
+        type: 'stdio',
+        command: config.command,
+        args: config.args ?? [],
+        ...(config.env ? { env: config.env } : {}),
+    };
+}

package/dist/services/sync/codex-writer.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfigWriter } from './agent-writer.js';
+export declare function createCodexWriter(): AgentConfigWriter;

package/dist/services/sync/codex-writer.js

@@ -0,0 +1,116 @@
+import { copyFile, mkdir, readdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { SyncError } from '../../errors.js';
+import { formatTimestamp } from './agent-writer.js';
+export function createCodexWriter() {
+    return {
+        async write(options) {
+            const configDir = path.join(homedir(), '.codex');
+            const configPath = path.join(configDir, 'config.toml');
+            let existingContent = '';
+            let backedUpTo = null;
+            // Read existing config
+            try {
+                existingContent = await readFile(configPath, 'utf8');
+            }
+            catch {
+                // No existing config
+            }
+            // Backup if file exists
+            if (existingContent.length > 0) {
+                const backupPath = `${configPath}.bak.${formatTimestamp()}`;
+                await copyFile(configPath, backupPath);
+                backedUpTo = backupPath;
+            }
+            // Build MCP servers section
+            const allServers = { ...options.mcpServers };
+            // Always include brainctl itself
+            allServers['brainctl'] = {
+                type: 'npm',
+                package: 'brainctl',
+            };
+            const mcpToml = buildMcpToml(allServers);
+            // Preserve non-mcp_servers content from existing config
+            const existingNonMcp = stripMcpSections(existingContent);
+            const finalContent = existingNonMcp.trim().length > 0
+                ? `${existingNonMcp.trim()}\n\n${mcpToml}`
+                : mcpToml;
+            // Atomic write
+            await mkdir(configDir, { recursive: true });
+            const tmpPath = `${configPath}.tmp.${Date.now()}`;
+            await writeFile(tmpPath, finalContent + '\n', 'utf8');
+            await rename(tmpPath, configPath);
+            return { configPath, backedUpTo };
+        },
+        async restore(options) {
+            const configPath = path.join(homedir(), '.codex', 'config.toml');
+            const dir = path.dirname(configPath);
+            const base = path.basename(configPath);
+            let entries;
+            try {
+                entries = await readdir(dir);
+            }
+            catch {
+                throw new SyncError('No Codex config directory found.');
+            }
+            const backups = entries
+                .filter((f) => f.startsWith(`${base}.bak.`))
+                .sort()
+                .reverse();
+            if (backups.length === 0) {
+                throw new SyncError('No Codex config backup found.');
+            }
+            const latestBackup = path.join(dir, backups[0]);
+            await copyFile(latestBackup, configPath);
+            return { restoredFrom: latestBackup };
+        },
+    };
+}
+function buildMcpToml(servers) {
+    const lines = [];
+    for (const [name, config] of Object.entries(servers)) {
+        lines.push(`[mcp_servers.${name}]`);
+        if (config.type === 'npm') {
+            lines.push(`command = "npx"`);
+            lines.push(`args = ["-y", ${tomlString(config.package)}]`);
+        }
+        else {
+            lines.push(`command = ${tomlString(config.command)}`);
+            if (config.args && config.args.length > 0) {
+                const argsStr = config.args.map(tomlString).join(', ');
+                lines.push(`args = [${argsStr}]`);
+            }
+        }
+        if (config.env && Object.keys(config.env).length > 0) {
+            lines.push('');
+            lines.push(`[mcp_servers.${name}.env]`);
+            for (const [key, value] of Object.entries(config.env)) {
+                lines.push(`${key} = ${tomlString(value)}`);
+            }
+        }
+        lines.push('');
+    }
+    return lines.join('\n').trim();
+}
+function tomlString(value) {
+    return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+function stripMcpSections(content) {
+    const lines = content.split('\n');
+    const result = [];
+    let inMcpSection = false;
+    for (const line of lines) {
+        if (/^\[mcp_servers[\].]/.test(line)) {
+            inMcpSection = true;
+            continue;
+        }
+        if (inMcpSection && /^\[/.test(line) && !/^\[mcp_servers[\].]/.test(line)) {
+            inMcpSection = false;
+        }
+        if (!inMcpSection) {
+            result.push(line);
+        }
+    }
+    return result.join('\n');
+}

package/dist/services/sync/gemini-writer.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfigWriter } from './agent-writer.js';
+export declare function createGeminiWriter(): AgentConfigWriter;

package/dist/services/sync/gemini-writer.js

@@ -0,0 +1,83 @@
+import { copyFile, mkdir, readdir, readFile, rename, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { SyncError } from '../../errors.js';
+import { formatTimestamp } from './agent-writer.js';
+export function createGeminiWriter() {
+    return {
+        async write(options) {
+            const geminiDir = path.join(options.cwd, '.gemini');
+            const configPath = path.join(geminiDir, 'settings.json');
+            let existing = {};
+            let backedUpTo = null;
+            // Read existing config
+            try {
+                const source = await readFile(configPath, 'utf8');
+                existing = JSON.parse(source);
+            }
+            catch {
+                // No existing config, start fresh
+            }
+            // Backup if file exists with content
+            if (Object.keys(existing).length > 0) {
+                const backupPath = `${configPath}.bak.${formatTimestamp()}`;
+                await copyFile(configPath, backupPath);
+                backedUpTo = backupPath;
+            }
+            // Build mcpServers
+            const mcpServers = {};
+            for (const [name, config] of Object.entries(options.mcpServers)) {
+                mcpServers[name] = toGeminiFormat(config);
+            }
+            // Always include brainctl itself
+            mcpServers['brainctl'] = {
+                command: 'npx',
+                args: ['-y', 'brainctl', 'mcp'],
+            };
+            // Merge into existing config (preserve other settings)
+            existing.mcpServers = mcpServers;
+            // Atomic write
+            await mkdir(geminiDir, { recursive: true });
+            const tmpPath = `${configPath}.tmp.${Date.now()}`;
+            await writeFile(tmpPath, JSON.stringify(existing, null, 2) + '\n', 'utf8');
+            await rename(tmpPath, configPath);
+            return { configPath, backedUpTo };
+        },
+        async restore(options) {
+            const configPath = path.join(options.cwd, '.gemini', 'settings.json');
+            const dir = path.dirname(configPath);
+            const base = path.basename(configPath);
+            let entries;
+            try {
+                entries = await readdir(dir);
+            }
+            catch {
+                throw new SyncError('No Gemini config directory found.');
+            }
+            const backups = entries
+                .filter((f) => f.startsWith(`${base}.bak.`))
+                .sort()
+                .reverse();
+            if (backups.length === 0) {
+                throw new SyncError('No Gemini config backup found.');
+            }
+            const latestBackup = path.join(dir, backups[0]);
+            await copyFile(latestBackup, configPath);
+            return { restoredFrom: latestBackup };
+        },
+    };
+}
+function toGeminiFormat(config) {
+    if (config.type === 'npm') {
+        return {
+            command: 'npx',
+            args: ['-y', config.package],
+            ...(config.env ? { env: config.env } : {}),
+        };
+    }
+    // bundled
+    return {
+        command: config.command,
+        args: config.args ?? [],
+        ...(config.env ? { env: config.env } : {}),
+    };
+}

package/dist/services/sync-service.d.ts

@@ -0,0 +1,15 @@
+import type { AgentName, SyncResult } from '../types.js';
+import type { AgentConfigWriter } from './sync/agent-writer.js';
+import { type ProfileService } from './profile-service.js';
+export interface SyncService {
+    execute(options?: {
+        cwd?: string;
+        restore?: boolean;
+    }): Promise<SyncResult>;
+}
+interface SyncServiceDependencies {
+    profileService?: ProfileService;
+    writers?: Partial<Record<AgentName, AgentConfigWriter>>;
+}
+export declare function createSyncService(dependencies?: SyncServiceDependencies): SyncService;
+export {};