brainctl 0.1.16 → 0.1.18

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

@@ -1,70 +0,0 @@
-import { lstat, mkdir, realpath, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import YAML from 'yaml';
-import { ConfigError } from '../errors.js';
-export function createConfigWriteService() {
-    return {
-        async execute(request) {
-            const cwd = request.cwd ?? process.cwd();
-            const configPath = path.join(cwd, 'ai-stack.yaml');
-            const memoryPaths = await Promise.all(request.config.memory.paths.map((memoryPath) => normalizeMemoryPath(cwd, memoryPath)));
-            const payload = {
-                memory: {
-                    paths: memoryPaths
-                },
-                skills: request.config.skills,
-                mcps: request.config.mcps
-            };
-            await mkdir(path.dirname(configPath), { recursive: true });
-            await writeFile(configPath, `${YAML.stringify(payload)}`, 'utf8');
-            return { configPath };
-        }
-    };
-}
-async function normalizeMemoryPath(cwd, filePath) {
-    const workspaceRoot = await realpath(cwd);
-    const resolvedPath = path.resolve(cwd, filePath);
-    const realTargetPath = await resolvePathForWrite(resolvedPath);
-    if (!isWithinDirectory(workspaceRoot, realTargetPath)) {
-        throw new ConfigError('Memory paths must stay within the workspace root.');
-    }
-    const relativePath = path.relative(cwd, resolvedPath);
-    return relativePath.length > 0 ? relativePath : '.';
-}
-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 ConfigError(`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/init-service.d.ts

@@ -1,14 +0,0 @@
-export interface InitServiceRequest {
-    cwd?: string;
-    force?: boolean;
-}
-export interface InitServiceResult {
-    created: string[];
-    replaced: string[];
-    skipped: string[];
-    alreadyInitialized: boolean;
-}
-export interface InitService {
-    execute(request?: InitServiceRequest): Promise<InitServiceResult>;
-}
-export declare function createInitService(): InitService;

package/dist/services/init-service.js

@@ -1,88 +0,0 @@
-import { mkdir, stat, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-const SAMPLE_CONFIG = `memory:
-  paths:
-    - ./memory
-
-skills:
-  summarize:
-    description: Summarize content
-    prompt: |
-      Summarize the following content into concise bullet points.
-
-  analyze:
-    description: Analyze content deeply
-    prompt: |
-      Analyze the following content and extract key insights.
-
-mcps: {}
-`;
-const SAMPLE_MEMORY = `# Team Notes
-
-- Track important project context here.
-- Keep prompts and references concise.
-`;
-export function createInitService() {
-    return {
-        async execute(request = {}) {
-            const cwd = request.cwd ?? process.cwd();
-            const force = request.force ?? false;
-            const configPath = path.join(cwd, 'ai-stack.yaml');
-            const memoryDir = path.join(cwd, 'memory');
-            const notesPath = path.join(memoryDir, 'notes.md');
-            const created = [];
-            const replaced = [];
-            const skipped = [];
-            await writeManagedFile({
-                targetPath: configPath,
-                content: SAMPLE_CONFIG,
-                force,
-                created,
-                replaced,
-                skipped
-            });
-            const memoryDirExists = await pathExists(memoryDir);
-            if (!memoryDirExists) {
-                await mkdir(memoryDir, { recursive: true });
-                created.push(memoryDir);
-            }
-            await writeManagedFile({
-                targetPath: notesPath,
-                content: SAMPLE_MEMORY,
-                force,
-                created,
-                replaced,
-                skipped
-            });
-            return {
-                created,
-                replaced,
-                skipped,
-                alreadyInitialized: created.length === 0 && replaced.length === 0
-            };
-        }
-    };
-}
-async function writeManagedFile(options) {
-    const exists = await pathExists(options.targetPath);
-    if (exists && !options.force) {
-        options.skipped.push(options.targetPath);
-        return;
-    }
-    await mkdir(path.dirname(options.targetPath), { recursive: true });
-    await writeFile(options.targetPath, options.content, 'utf8');
-    if (exists) {
-        options.replaced.push(options.targetPath);
-        return;
-    }
-    options.created.push(options.targetPath);
-}
-async function pathExists(targetPath) {
-    try {
-        await stat(targetPath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/services/memory-write-service.d.ts

@@ -1,12 +0,0 @@
-export interface MemoryWriteRequest {
-    cwd?: string;
-    filePath: string;
-    content: string;
-}
-export interface MemoryWriteResult {
-    filePath: string;
-}
-export interface MemoryWriteService {
-    execute(request: MemoryWriteRequest): Promise<MemoryWriteResult>;
-}
-export declare function createMemoryWriteService(): MemoryWriteService;

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

@@ -1,56 +0,0 @@
-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/run-service.d.ts

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

package/dist/services/run-service.js

@@ -1,94 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
-import { AgentNotAvailableError, InputFileError } from '../errors.js';
-import { loadConfig } from '../config.js';
-import { buildContext } from '../context/builder.js';
-import { loadMemory } from '../context/memory.js';
-import { resolveSkillPrompt } from '../context/skills.js';
-import { createExecutorResolver } from '../executor/resolver.js';
-export function createRunService(dependencies = {}) {
-    const resolver = dependencies.resolver ?? createExecutorResolver();
-    return {
-        async execute(request, options = {}) {
-            const cwd = request.cwd ?? process.cwd();
-            const config = await loadConfig({ cwd });
-            const memory = await loadMemory({ paths: config.memory.paths });
-            const steps = buildExecutionPlan(request);
-            const results = [];
-            let previousOutput;
-            for (const [stepIndex, step] of steps.entries()) {
-                const input = await resolveInput(step, cwd, previousOutput);
-                const skill = resolveSkillPrompt(config, step.skill);
-                const context = buildContext({
-                    memory: memory.content,
-                    skill,
-                    input
-                });
-                let executor = await resolvePrimaryExecutor(resolver, step);
-                let fallbackUsed = false;
-                if (executor.fallbackRequired) {
-                    fallbackUsed = true;
-                }
-                const result = await executor.instance.run(context, {
-                    streamOutput: options.streamOutput ?? true,
-                    onOutputChunk: options.onOutputChunk
-                });
-                previousOutput = result.output;
-                results.push({
-                    stepIndex,
-                    requestedAgent: step.primaryAgent,
-                    agent: result.agent,
-                    fallbackUsed,
-                    exitCode: result.exitCode,
-                    output: result.output
-                });
-            }
-            const finalResult = results.at(-1);
-            return {
-                steps: results,
-                finalOutput: finalResult?.output ?? '',
-                finalExitCode: finalResult?.exitCode ?? 0
-            };
-        }
-    };
-}
-export function buildExecutionPlan(request) {
-    return [
-        {
-            skill: request.skill,
-            inputFile: request.inputFile,
-            primaryAgent: request.primaryAgent,
-            fallbackAgent: request.fallbackAgent,
-            usePreviousOutput: false
-        }
-    ];
-}
-async function resolveInput(step, cwd, previousOutput) {
-    if (step.usePreviousOutput && previousOutput !== undefined) {
-        return previousOutput;
-    }
-    const inputPath = path.resolve(cwd, step.inputFile);
-    try {
-        return await readFile(inputPath, 'utf8');
-    }
-    catch (error) {
-        throw new InputFileError(`Could not read input file: ${step.inputFile}`);
-    }
-}
-async function resolvePrimaryExecutor(resolver, step) {
-    try {
-        return {
-            instance: await resolver.resolveExecutor(step.primaryAgent),
-            fallbackRequired: false
-        };
-    }
-    catch (error) {
-        if (!(error instanceof AgentNotAvailableError) || !step.fallbackAgent) {
-            throw error;
-        }
-        return {
-            instance: await resolver.resolveExecutor(step.fallbackAgent),
-            fallbackRequired: true
-        };
-    }
-}

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

@@ -1,15 +0,0 @@
-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 {};

package/dist/services/sync-service.js

@@ -1,69 +0,0 @@
-import { ProfileError } from '../errors.js';
-import { createClaudeWriter } from './sync/claude-writer.js';
-import { createCodexWriter } from './sync/codex-writer.js';
-import { createGeminiWriter } from './sync/gemini-writer.js';
-import { createProfileService } from './profile-service.js';
-export function createSyncService(dependencies = {}) {
-    const profileService = dependencies.profileService ?? createProfileService();
-    const defaultWriters = {
-        claude: createClaudeWriter(),
-        codex: createCodexWriter(),
-        gemini: createGeminiWriter(),
-    };
-    const writers = { ...defaultWriters, ...dependencies.writers };
-    return {
-        async execute(options = {}) {
-            const cwd = options.cwd ?? process.cwd();
-            if (options.restore) {
-                return restoreAll(writers, cwd);
-            }
-            const meta = await profileService.getMetaConfig({ cwd });
-            if (!meta.active_profile) {
-                throw new Error('No active profile set. Run "brainctl profile use <name>" first.');
-            }
-            const profile = await profileService.get({ cwd, name: meta.active_profile });
-            const remoteMcpName = Object.entries(profile.mcps).find(([, config]) => config.kind === 'remote')?.[0];
-            if (remoteMcpName) {
-                throw new ProfileError(`Profile "${profile.name}" includes remote MCP "${remoteMcpName}". Remote MCP sync is not supported yet.`);
-            }
-            const results = [];
-            for (const agent of meta.agents) {
-                const writer = writers[agent];
-                if (!writer) {
-                    continue;
-                }
-                const result = await writer.write({
-                    mcpServers: profile.mcps,
-                    cwd,
-                });
-                results.push({
-                    agent,
-                    configPath: result.configPath,
-                    backedUpTo: result.backedUpTo,
-                    mcpCount: Object.keys(profile.mcps).length,
-                });
-            }
-            return results;
-        },
-    };
-}
-async function restoreAll(writers, cwd) {
-    const results = [];
-    for (const [agent, writer] of Object.entries(writers)) {
-        if (!writer)
-            continue;
-        try {
-            const { restoredFrom } = await writer.restore({ cwd });
-            results.push({
-                agent: agent,
-                configPath: restoredFrom,
-                backedUpTo: null,
-                mcpCount: 0,
-            });
-        }
-        catch {
-            // Skip agents with no backup
-        }
-    }
-    return results;
-}

package/dist/ui/streaming.d.ts

@@ -1,3 +0,0 @@
-import type { ServerResponse } from 'node:http';
-export declare function startSseStream(response: ServerResponse): void;
-export declare function writeSseEvent(response: ServerResponse, event: string, data: unknown): void;

package/dist/ui/streaming.js

@@ -1,16 +0,0 @@
-export function startSseStream(response) {
-    response.statusCode = 200;
-    response.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
-    response.setHeader('Cache-Control', 'no-cache, no-transform');
-    response.setHeader('Connection', 'keep-alive');
-    response.setHeader('X-Accel-Buffering', 'no');
-    response.flushHeaders?.();
-}
-export function writeSseEvent(response, event, data) {
-    response.write(`event: ${event}\n`);
-    const payload = typeof data === 'string' ? data : JSON.stringify(data);
-    for (const line of payload.split(/\r?\n/)) {
-        response.write(`data: ${line}\n`);
-    }
-    response.write('\n');
-}