fraim-framework 2.0.122 → 2.0.123

package/dist/src/ai-hub/catalog.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeProject = summarizeProject;
+exports.discoverEmployeeJobs = discoverEmployeeJobs;
+exports.discoverManagerTemplates = discoverManagerTemplates;
+exports.getAiHubCategories = getAiHubCategories;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+const EMPLOYEE_CATEGORIES = {
+    marketing: {
+        id: 'marketing',
+        label: 'Marketing',
+        description: 'Content, campaign, and creative production jobs.',
+    },
+    'go-to-market': {
+        id: 'go-to-market',
+        label: 'GTM',
+        description: 'Launch, distribution, and growth execution jobs.',
+    },
+};
+const MANAGER_GROUPS = {
+    coaching: 'Coaching',
+    delegation: 'Delegation',
+};
+const sectionValue = (content, heading) => {
+    const match = content.match(new RegExp(`## ${heading}\\r?\\n([\\s\\S]*?)(?:\\r?\\n## |\\r?\\n---|$)`));
+    if (!match)
+        return [];
+    return match[1]
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => line.replace(/^[-*]\s*/, '').trim());
+};
+const humanizeJobName = (jobName) => jobName
+    .split('-')
+    .map((part) => (part.length > 0 ? `${part[0].toUpperCase()}${part.slice(1)}` : part))
+    .join(' ');
+const toPosix = (value) => value.replace(/\\/g, '/');
+function parseJobStub(filePath, categoryId, projectPath) {
+    const content = fs_1.default.readFileSync(filePath, 'utf8');
+    const fileName = path_1.default.basename(filePath, '.md');
+    const intent = sectionValue(content, 'Intent')[0] || 'No intent summary available.';
+    const outcome = sectionValue(content, 'Outcome');
+    return {
+        id: fileName,
+        title: humanizeJobName(fileName),
+        categoryId,
+        categoryLabel: EMPLOYEE_CATEGORIES[categoryId].label,
+        intent,
+        outcome,
+        stubPath: toPosix(path_1.default.relative(projectPath, filePath)),
+    };
+}
+function parseManagerStub(filePath, groupId, projectPath) {
+    const content = fs_1.default.readFileSync(filePath, 'utf8');
+    const fileName = path_1.default.basename(filePath, '.md');
+    const intent = sectionValue(content, 'Intent')[0] || 'No intent summary available.';
+    return {
+        id: fileName,
+        title: humanizeJobName(fileName),
+        groupId,
+        groupLabel: MANAGER_GROUPS[groupId],
+        intent,
+        stubPath: toPosix(path_1.default.relative(projectPath, filePath)),
+    };
+}
+const readMarkdownFiles = (dirPath) => {
+    if (!fs_1.default.existsSync(dirPath))
+        return [];
+    return fs_1.default
+        .readdirSync(dirPath, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+        .map((entry) => path_1.default.join(dirPath, entry.name))
+        .sort((a, b) => a.localeCompare(b));
+};
+function summarizeProject(projectPath) {
+    if (!projectPath) {
+        return {
+            path: '',
+            exists: false,
+            hasFraim: false,
+            message: 'Choose a project path to load FRAIM jobs.',
+        };
+    }
+    if (!fs_1.default.existsSync(projectPath)) {
+        return {
+            path: projectPath,
+            exists: false,
+            hasFraim: false,
+            message: 'Project path does not exist on this machine.',
+        };
+    }
+    const fraimDir = (0, project_fraim_paths_1.getWorkspaceFraimDir)(projectPath);
+    if (!fs_1.default.existsSync(fraimDir)) {
+        return {
+            path: projectPath,
+            exists: true,
+            hasFraim: false,
+            message: 'This folder does not contain a local fraim/ directory.',
+        };
+    }
+    return {
+        path: projectPath,
+        exists: true,
+        hasFraim: true,
+    };
+}
+function discoverEmployeeJobs(projectPath) {
+    const project = summarizeProject(projectPath);
+    if (!project.exists || !project.hasFraim)
+        return [];
+    const fraimDir = (0, project_fraim_paths_1.getWorkspaceFraimDir)(projectPath);
+    return Object.keys(EMPLOYEE_CATEGORIES)
+        .flatMap((categoryId) => readMarkdownFiles(path_1.default.join(fraimDir, 'ai-employee', 'jobs', categoryId)).map((filePath) => parseJobStub(filePath, categoryId, projectPath)));
+}
+function discoverManagerTemplates(projectPath) {
+    const project = summarizeProject(projectPath);
+    if (!project.exists || !project.hasFraim)
+        return [];
+    const fraimDir = (0, project_fraim_paths_1.getWorkspaceFraimDir)(projectPath);
+    return Object.keys(MANAGER_GROUPS)
+        .flatMap((groupId) => readMarkdownFiles(path_1.default.join(fraimDir, 'ai-manager', 'jobs', groupId)).map((filePath) => parseManagerStub(filePath, groupId, projectPath)));
+}
+function getAiHubCategories() {
+    return Object.values(EMPLOYEE_CATEGORIES);
+}

package/dist/src/ai-hub/desktop-main.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launchDesktopShell = launchDesktopShell;
+const electron_1 = require("electron");
+const server_1 = require("./server");
+let server = null;
+let mainWindow = null;
+let stopping = null;
+function preferredWindowSize() {
+    const primaryDisplay = electron_1.screen.getPrimaryDisplay();
+    const workArea = primaryDisplay.workAreaSize;
+    return {
+        width: Math.max(1440, Math.min(1680, workArea.width)),
+        height: Math.max(980, Math.min(1180, workArea.height)),
+    };
+}
+function parseArgs(argv) {
+    let projectPath = process.cwd();
+    let preferredPort = 43091;
+    for (let index = 0; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value === '--project-path' && argv[index + 1]) {
+            projectPath = argv[index + 1];
+            index += 1;
+            continue;
+        }
+        if (value === '--port' && argv[index + 1]) {
+            preferredPort = Number(argv[index + 1]) || preferredPort;
+            index += 1;
+        }
+    }
+    return { projectPath, preferredPort };
+}
+async function stopServer() {
+    if (!server)
+        return;
+    await server.stop();
+    server = null;
+}
+function stopServerOnce() {
+    if (!stopping) {
+        stopping = stopServer().finally(() => {
+            stopping = null;
+        });
+    }
+    return stopping;
+}
+async function createWindow(url) {
+    const { width, height } = preferredWindowSize();
+    mainWindow = new electron_1.BrowserWindow({
+        title: 'Visa AI Hub',
+        width,
+        height,
+        minWidth: 1400,
+        minHeight: 960,
+        useContentSize: true,
+        autoHideMenuBar: true,
+        backgroundColor: '#f2f5fb',
+        show: false,
+        webPreferences: {
+            contextIsolation: true,
+            nodeIntegration: false,
+            sandbox: true,
+        },
+    });
+    electron_1.Menu.setApplicationMenu(null);
+    mainWindow.webContents.setWindowOpenHandler(({ url: targetUrl }) => {
+        void electron_1.shell.openExternal(targetUrl);
+        return { action: 'deny' };
+    });
+    mainWindow.once('ready-to-show', () => {
+        mainWindow?.show();
+    });
+    mainWindow.on('closed', () => {
+        mainWindow = null;
+    });
+    await mainWindow.loadURL(url);
+    mainWindow.webContents.setZoomFactor(1);
+}
+async function launchDesktopShell(options) {
+    const port = await (0, server_1.findAvailablePort)(options.preferredPort);
+    server = new server_1.AiHubServer({ projectPath: options.projectPath });
+    await server.start(port);
+    await createWindow(`http://127.0.0.1:${port}/ai-hub/`);
+}
+async function bootstrap() {
+    const options = parseArgs(process.argv.slice(2));
+    await electron_1.app.whenReady();
+    electron_1.app.setName('Visa AI Hub');
+    electron_1.app.on('activate', () => {
+        if (electron_1.BrowserWindow.getAllWindows().length === 0) {
+            void launchDesktopShell(options);
+        }
+    });
+    electron_1.app.on('before-quit', () => {
+        void stopServerOnce();
+    });
+    electron_1.app.on('window-all-closed', () => {
+        void stopServerOnce().finally(() => {
+            electron_1.app.quit();
+        });
+    });
+    await launchDesktopShell(options);
+}
+if (process.versions.electron && process.type !== 'renderer') {
+    bootstrap().catch(async (error) => {
+        console.error(error instanceof Error ? error.message : error);
+        await stopServerOnce();
+        electron_1.app.exit(1);
+    });
+}

package/dist/src/ai-hub/hosts.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHubEvent = exports.createHubMessage = exports.FakeHostRuntime = exports.CliHostRuntime = void 0;
+exports.detectEmployees = detectEmployees;
+exports.buildStartPlan = buildStartPlan;
+exports.buildContinuePlan = buildContinuePlan;
+exports.parseHostLine = parseHostLine;
+const crypto_1 = require("crypto");
+const child_process_1 = require("child_process");
+const EMPLOYEE_LABELS = {
+    codex: 'Codex',
+    claude: 'Claude Code',
+};
+const executableName = (command) => command;
+function quoteWindowsArg(value) {
+    if (value.length === 0) {
+        return '""';
+    }
+    return `"${value.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/g, '$1$1')}"`;
+}
+function escapeWindowsArg(value) {
+    return /[\s"]/u.test(value) ? quoteWindowsArg(value) : value;
+}
+function resolveHostInvocation(plan) {
+    if (process.platform !== 'win32') {
+        return plan;
+    }
+    const [command, ...args] = [plan.command, ...plan.args];
+    return {
+        command: 'cmd.exe',
+        args: ['/d', '/s', '/c', [command, ...args.map(escapeWindowsArg)].join(' ')],
+    };
+}
+const availableByVersionProbe = (command) => {
+    const invocation = resolveHostInvocation({ command, args: ['--version'] });
+    const result = (0, child_process_1.spawnSync)(invocation.command, invocation.args, {
+        encoding: 'utf8',
+    });
+    return result.status === 0;
+};
+function detectEmployees() {
+    return Object.keys(EMPLOYEE_LABELS).map((id) => {
+        const available = id === 'codex'
+            ? availableByVersionProbe(executableName('codex'))
+            : availableByVersionProbe(executableName('claude'));
+        return {
+            id,
+            label: EMPLOYEE_LABELS[id],
+            available,
+            detail: available ? 'Installed and ready on this machine.' : 'CLI not detected on this machine.',
+        };
+    });
+}
+function buildStartPlan(hostId, message) {
+    if (hostId === 'codex') {
+        return {
+            command: executableName('codex'),
+            args: ['exec', '--json', '--skip-git-repo-check', '--dangerously-bypass-approvals-and-sandbox'],
+            stdin: message,
+        };
+    }
+    return {
+        command: executableName('claude'),
+        args: ['-p', '--verbose', '--output-format', 'stream-json', '--dangerously-skip-permissions'],
+        stdin: message,
+    };
+}
+function buildContinuePlan(hostId, sessionId, message) {
+    if (hostId === 'codex') {
+        return {
+            command: executableName('codex'),
+            args: ['exec', 'resume', '--json', '--skip-git-repo-check', '--dangerously-bypass-approvals-and-sandbox', sessionId],
+            stdin: message,
+        };
+    }
+    return {
+        command: executableName('claude'),
+        args: ['-p', '--verbose', '--output-format', 'stream-json', '--dangerously-skip-permissions', '-r', sessionId],
+        stdin: message,
+    };
+}
+function parseHostLine(hostId, line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return {};
+    if (hostId === 'codex') {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed.type === 'thread.started' && parsed.thread_id) {
+                return { sessionId: parsed.thread_id, raw: trimmed };
+            }
+            if (parsed.type === 'item.completed' && parsed.item?.type === 'agent_message' && parsed.item.text) {
+                return { message: parsed.item.text, raw: trimmed };
+            }
+            return { raw: trimmed };
+        }
+        catch {
+            return { raw: trimmed };
+        }
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed.type === 'system' && parsed.session_id) {
+            return { sessionId: parsed.session_id, raw: trimmed };
+        }
+        if (parsed.type === 'assistant') {
+            const text = parsed.message?.content?.find((entry) => entry.type === 'text')?.text;
+            if (text) {
+                return { message: text, sessionId: parsed.session_id, raw: trimmed };
+            }
+        }
+        if (parsed.type === 'result' && parsed.result) {
+            return { message: parsed.result, sessionId: parsed.session_id, raw: trimmed };
+        }
+        return { raw: trimmed };
+    }
+    catch {
+        return { raw: trimmed };
+    }
+}
+function wireHostProcess(hostId, child, handlers) {
+    const wire = (buffer, channel) => {
+        let pending = '';
+        buffer.on('data', (chunk) => {
+            pending += chunk.toString();
+            const lines = pending.split(/\r?\n/);
+            pending = lines.pop() || '';
+            for (const line of lines) {
+                const parsed = parseHostLine(hostId, line);
+                if (parsed.message || parsed.sessionId || parsed.raw) {
+                    handlers.onEvent(parsed, channel);
+                }
+            }
+        });
+        buffer.on('end', () => {
+            if (pending.trim().length > 0) {
+                const parsed = parseHostLine(hostId, pending);
+                if (parsed.message || parsed.sessionId || parsed.raw) {
+                    handlers.onEvent(parsed, channel);
+                }
+            }
+        });
+    };
+    wire(child.stdout, 'stdout');
+    wire(child.stderr, 'stderr');
+    child.on('close', (code) => handlers.onExit(code));
+    return child;
+}
+function spawnHostProcess(hostId, plan, projectPath, handlers) {
+    const invocation = resolveHostInvocation(plan);
+    const child = (0, child_process_1.spawn)(invocation.command, invocation.args, {
+        cwd: projectPath,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: process.env,
+    });
+    if (typeof plan.stdin === 'string') {
+        child.stdin.write(plan.stdin);
+    }
+    child.stdin.end();
+    return wireHostProcess(hostId, child, handlers);
+}
+class CliHostRuntime {
+    detectEmployees() {
+        return detectEmployees();
+    }
+    startRun(hostId, projectPath, message, handlers) {
+        return spawnHostProcess(hostId, buildStartPlan(hostId, message), projectPath, handlers);
+    }
+    continueRun(hostId, projectPath, sessionId, message, handlers) {
+        return spawnHostProcess(hostId, buildContinuePlan(hostId, sessionId, message), projectPath, handlers);
+    }
+}
+exports.CliHostRuntime = CliHostRuntime;
+class FakeHostRuntime {
+    constructor() {
+        this.employees = [
+            { id: 'codex', label: 'Codex', available: true, detail: 'Test double employee.' },
+            { id: 'claude', label: 'Claude Code', available: true, detail: 'Test double employee.' },
+        ];
+    }
+    detectEmployees() {
+        return this.employees;
+    }
+    startRun(hostId, _projectPath, message, handlers) {
+        return this.fakeProcess(hostId, `Started ${hostId}: ${message}`, handlers);
+    }
+    continueRun(hostId, _projectPath, sessionId, message, handlers) {
+        return this.fakeProcess(hostId, `Resumed ${hostId} session ${sessionId}: ${message}`, handlers);
+    }
+    fakeProcess(_hostId, text, handlers) {
+        handlers.onEvent({ sessionId: (0, crypto_1.randomUUID)(), raw: 'fake-session-start' }, 'system');
+        handlers.onEvent({ message: text, raw: text }, 'stdout');
+        setTimeout(() => handlers.onExit(0), 25);
+        return {
+            stdout: process.stdout,
+            stderr: process.stderr,
+            stdin: process.stdin,
+            kill: () => true,
+            on: () => ({}),
+            once: () => ({}),
+            emit: () => true,
+            addListener: () => ({}),
+            removeListener: () => ({}),
+            removeAllListeners: () => ({}),
+            setMaxListeners: () => ({}),
+            getMaxListeners: () => 0,
+            listeners: () => [],
+            rawListeners: () => [],
+            listenerCount: () => 0,
+            prependListener: () => ({}),
+            prependOnceListener: () => ({}),
+            eventNames: () => [],
+            pid: 0,
+            connected: false,
+            disconnect: () => undefined,
+            exitCode: 0,
+            killed: false,
+            signalCode: null,
+            spawnargs: [],
+            spawnfile: '',
+            stdio: [],
+            unref: () => undefined,
+            ref: () => undefined,
+        };
+    }
+}
+exports.FakeHostRuntime = FakeHostRuntime;
+const createHubMessage = (role, text) => ({
+    id: (0, crypto_1.randomUUID)(),
+    role,
+    text,
+    createdAt: new Date().toISOString(),
+});
+exports.createHubMessage = createHubMessage;
+const createHubEvent = (channel, text) => ({
+    id: (0, crypto_1.randomUUID)(),
+    channel,
+    text,
+    createdAt: new Date().toISOString(),
+});
+exports.createHubEvent = createHubEvent;

package/dist/src/ai-hub/preferences.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiHubPreferencesStore = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+const DEFAULT_CATEGORY = 'marketing';
+const DEFAULT_EMPLOYEE = 'codex';
+const defaultPreferences = (projectPath) => ({
+    projectPath,
+    employeeId: DEFAULT_EMPLOYEE,
+    categoryId: DEFAULT_CATEGORY,
+    recentJobIds: [],
+});
+class AiHubPreferencesStore {
+    constructor(stateFilePath = path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'ai-hub-state.json')) {
+        this.stateFilePath = stateFilePath;
+    }
+    load(projectPath) {
+        if (!fs_1.default.existsSync(this.stateFilePath)) {
+            return defaultPreferences(projectPath);
+        }
+        try {
+            const raw = JSON.parse(fs_1.default.readFileSync(this.stateFilePath, 'utf8'));
+            return {
+                projectPath: raw.projectPath || projectPath,
+                employeeId: raw.employeeId === 'claude' ? 'claude' : DEFAULT_EMPLOYEE,
+                categoryId: raw.categoryId === 'go-to-market' ? 'go-to-market' : DEFAULT_CATEGORY,
+                recentJobIds: Array.isArray(raw.recentJobIds) ? raw.recentJobIds.filter((value) => typeof value === 'string') : [],
+            };
+        }
+        catch {
+            return defaultPreferences(projectPath);
+        }
+    }
+    save(preferences) {
+        fs_1.default.mkdirSync(path_1.default.dirname(this.stateFilePath), { recursive: true });
+        fs_1.default.writeFileSync(this.stateFilePath, JSON.stringify(preferences, null, 2));
+    }
+    remember(preferences, jobId) {
+        const recentJobIds = jobId
+            ? [jobId, ...preferences.recentJobIds.filter((value) => value !== jobId)].slice(0, 8)
+            : preferences.recentJobIds.slice(0, 8);
+        const next = {
+            ...preferences,
+            recentJobIds,
+        };
+        this.save(next);
+        return next;
+    }
+}
+exports.AiHubPreferencesStore = AiHubPreferencesStore;