monomind 2.7.11 → 2.7.13

package/packages/@monomind/cli/dist/src/agents/registry-builder.js

@@ -1,228 +0,0 @@
-/**
- * Registry Builder (Task 30)
- *
- * Scans agent definition .md files, parses YAML frontmatter,
- * and produces a unified AgentRegistry JSON.
- */
-import { readFileSync, writeFileSync, readdirSync, statSync } from 'fs';
-import { join, basename, relative, extname, isAbsolute } from 'path';
-/** Directories to skip during recursive scan. */
-const SKIP_DIRS = new Set(['schemas', 'ephemeral']);
-/**
- * Recursively collect all `.md` files under `root`, skipping SKIP_DIRS.
- */
-function collectMdFiles(root, base = root) {
-    const results = [];
-    let entries;
-    try {
-        entries = readdirSync(root);
-    }
-    catch {
-        return results;
-    }
-    for (const entry of entries) {
-        const full = join(root, entry);
-        let stat;
-        try {
-            stat = statSync(full);
-        }
-        catch {
-            continue;
-        }
-        if (stat.isDirectory()) {
-            if (SKIP_DIRS.has(entry))
-                continue;
-            results.push(...collectMdFiles(full, base));
-        }
-        else if (stat.isFile() && extname(entry) === '.md' && !entry.startsWith('._')) {
-            results.push(full);
-        }
-    }
-    return results;
-}
-/**
- * Parse YAML frontmatter from markdown content using simple regex.
- * Returns key-value pairs from the `---` delimited block.
- */
-function parseFrontmatter(content) {
-    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-    if (!match)
-        return {};
-    const block = match[1];
-    const result = {};
-    for (const line of block.split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#'))
-            continue;
-        const colonIdx = trimmed.indexOf(':');
-        if (colonIdx === -1)
-            continue;
-        const key = trimmed.slice(0, colonIdx).trim();
-        let value = trimmed.slice(colonIdx + 1).trim();
-        // Handle YAML arrays written as "[a, b, c]"
-        if (typeof value === 'string' && value.startsWith('[') && value.endsWith(']')) {
-            value = value
-                .slice(1, -1)
-                .split(',')
-                .map((s) => s.trim().replace(/^["']|["']$/g, ''))
-                .filter(Boolean);
-        }
-        // Handle booleans
-        else if (value === 'true')
-            value = true;
-        else if (value === 'false')
-            value = false;
-        // Handle quoted strings
-        else if (typeof value === 'string' &&
-            ((value.startsWith('"') && value.endsWith('"')) ||
-                (value.startsWith("'") && value.endsWith("'")))) {
-            value = value.slice(1, -1);
-        }
-        result[key] = value;
-    }
-    return result;
-}
-/** Coerce a value into a string array. */
-function toStringArray(val) {
-    if (Array.isArray(val))
-        return val.map(String);
-    if (typeof val === 'string' && val.length > 0)
-        return [val];
-    return [];
-}
-/** Parse trigger patterns from frontmatter value. */
-function parseTriggers(val) {
-    if (!val)
-        return [];
-    const arr = Array.isArray(val) ? val : [val];
-    return arr.map((t) => {
-        if (typeof t === 'object' && t !== null && 'pattern' in t) {
-            return {
-                pattern: String(t.pattern),
-                mode: String(t.mode ?? 'glob'),
-            };
-        }
-        return { pattern: String(t), mode: 'glob' };
-    });
-}
-/**
- * Derive a slug from a filename: remove extension, lowercase, replace spaces with hyphens.
- */
-function slugFromFilename(filename) {
-    return basename(filename, extname(filename))
-        .toLowerCase()
-        .replace(/\s+/g, '-')
-        .replace(/[^a-z0-9-]/g, '');
-}
-/**
- * Derive category from the parent directory name relative to agents root.
- */
-function categoryFromPath(filePath, agentsRoot) {
-    const rel = relative(agentsRoot, filePath);
-    const parts = rel.split('/');
-    return parts.length > 1 ? parts[0] : 'default';
-}
-/**
- * Build the agent registry by scanning `.md` files under `agentsRoot`.
- *
- * @param agentsRoot - Root directory (or array of directories) to scan.
- * @param outputPath - Optional path to write the registry JSON file.
- * @returns The built AgentRegistry object.
- */
-export function buildRegistry(agentsRoot, outputPath) {
-    return buildUnifiedRegistry([agentsRoot], outputPath);
-}
-/**
- * Compute the ordered list of agent-definition roots for `cwd`: extras
- * (canonical, from MONOMIND_EXTRA_AGENT_PATHS or a sibling `agency-agents`
- * dir) first, then the project's `.claude/agents`. Shared by CLI startup
- * and `monomind doctor` so both build the registry the same way.
- */
-export function computeAgentRoots(cwd) {
-    const devAgentsRoot = join(cwd, '.claude', 'agents');
-    const extraPaths = process.env.MONOMIND_EXTRA_AGENT_PATHS
-        ? process.env.MONOMIND_EXTRA_AGENT_PATHS.split(':').filter(Boolean)
-        : [];
-    const siblingExtraPath = join(cwd, '..', 'agency-agents');
-    if (extraPaths.length === 0) {
-        try {
-            if (statSync(siblingExtraPath).isDirectory())
-                extraPaths.push(siblingExtraPath);
-        }
-        catch { /* sibling path doesn't exist */ }
-    }
-    return [...extraPaths, devAgentsRoot];
-}
-/**
- * Build a unified agent registry from multiple root directories, deduplicating
- * by slug. When the same slug appears in more than one root, the entry from the
- * **first** root in the array wins (earlier roots are considered canonical).
- *
- * Typical usage — extras (agency-agents) listed first so they take precedence
- * over any locally duplicated copies in `.claude/agents/`:
- *
- * ```ts
- * buildUnifiedRegistry([
- *   '/path/to/agency-agents',   // canonical source — wins on conflict
- *   '.claude/agents',           // dev copies — used only for unique slugs
- * ], '.monomind/registry.json');
- * ```
- *
- * @param roots      - Ordered list of directories to scan (first-wins on slug conflict).
- * @param outputPath - Optional path to write the merged registry JSON file.
- * @returns The deduplicated AgentRegistry.
- */
-export function buildUnifiedRegistry(roots, outputPath) {
-    const now = new Date().toISOString();
-    /** Slug → first-seen entry (first root wins). */
-    const seen = new Map();
-    for (const root of roots) {
-        const files = collectMdFiles(root);
-        for (const file of files) {
-            let content;
-            try {
-                if (statSync(file).size > 512 * 1024)
-                    continue; // skip files > 512 KB
-                content = readFileSync(file, 'utf-8');
-            }
-            catch {
-                continue;
-            }
-            const fm = parseFrontmatter(content);
-            const slug = (typeof fm.slug === 'string' ? fm.slug : undefined) || slugFromFilename(file);
-            // Skip duplicates — first root wins
-            if (seen.has(slug))
-                continue;
-            seen.set(slug, {
-                slug,
-                name: (typeof fm.name === 'string' ? fm.name : undefined) || slug,
-                version: (typeof fm.version === 'string' ? fm.version : undefined) || '0.0.0',
-                category: (typeof fm.category === 'string' ? fm.category : undefined) ||
-                    categoryFromPath(file, root),
-                description: typeof fm.description === 'string' ? fm.description : '',
-                capabilities: toStringArray(fm.capabilities),
-                taskTypes: toStringArray(fm.taskTypes ?? fm['task-types'] ?? fm.task_types),
-                tools: toStringArray(fm.tools),
-                triggers: parseTriggers(fm.triggers),
-                deprecated: fm.deprecated === true,
-                deprecatedBy: typeof fm.deprecatedBy === 'string' ? fm.deprecatedBy : undefined,
-                dependencies: toStringArray(fm.dependencies),
-                filePath: isAbsolute(file) ? relative(process.cwd(), file) : file,
-                registeredAt: now,
-                lastUpdated: now,
-            });
-        }
-    }
-    const agents = Array.from(seen.values());
-    const registry = {
-        version: '1.0.0',
-        generatedAt: now,
-        totalAgents: agents.length,
-        agents,
-    };
-    if (outputPath) {
-        writeFileSync(outputPath, JSON.stringify(registry, null, 2), 'utf-8');
-    }
-    return registry;
-}
-//# sourceMappingURL=registry-builder.js.map

package/packages/@monomind/cli/dist/src/autopilot-state.d.ts

@@ -1,77 +0,0 @@
-/**
- * Autopilot Shared State Module
- *
- * Centralizes state management, validation, and task discovery
- * for both CLI command and MCP tools. Eliminates code duplication.
- *
- * ADR-072: Autopilot Integration
- * Security: Addresses prototype pollution, NaN bypass, input validation
- */
-export declare const STATE_DIR = ".monomind/data";
-export declare const STATE_FILE = ".monomind/data/autopilot-state.json";
-export declare const LOG_FILE = ".monomind/data/autopilot-log.json";
-/** Allowlist for valid task sources */
-export declare const VALID_TASK_SOURCES: Set<string>;
-/** Terminal task statuses */
-export declare const TERMINAL_STATUSES: Set<string>;
-export interface AutopilotState {
-    sessionId: string;
-    enabled: boolean;
-    startTime: number;
-    iterations: number;
-    maxIterations: number;
-    timeoutMinutes: number;
-    taskSources: string[];
-    lastCheck: number | null;
-    history: Array<{
-        ts: number;
-        iteration: number;
-        completed: number;
-        total: number;
-    }>;
-}
-export interface AutopilotLogEntry {
-    ts: number;
-    event: string;
-    [key: string]: unknown;
-}
-export interface TaskInfo {
-    id: string;
-    subject: string;
-    status: string;
-    source: string;
-}
-export interface TaskProgress {
-    completed: number;
-    total: number;
-    percent: number;
-    incomplete: TaskInfo[];
-}
-/**
- * Safe JSON.parse that prevents prototype pollution.
- */
-export declare function safeJsonParse<T>(raw: string): T;
-/**
- * Validate and coerce a numeric parameter. Returns the default if
- * the input is NaN, undefined, or outside the allowed range.
- */
-export declare function validateNumber(value: unknown, min: number, max: number, defaultValue: number): number;
-/**
- * Validate task sources against the allowlist.
- * Returns only valid sources; falls back to defaults if none are valid.
- */
-export declare function validateTaskSources(sources: unknown): string[];
-export declare function getDefaultState(): AutopilotState;
-export declare function loadState(): AutopilotState;
-export declare function saveState(state: AutopilotState): void;
-export declare function appendLog(entry: AutopilotLogEntry): void;
-export declare function loadLog(): AutopilotLogEntry[];
-export declare function discoverTasks(sources: string[]): TaskInfo[];
-export declare function isTerminal(status: string): boolean;
-export declare function getProgress(tasks: TaskInfo[]): TaskProgress;
-export declare function calculateReward(iterations: number, durationMs: number): number;
-export declare function tryLoadLearning(): Promise<{
-    initialize: () => Promise<boolean>;
-    [key: string]: unknown;
-} | null>;
-//# sourceMappingURL=autopilot-state.d.ts.map

package/packages/@monomind/cli/dist/src/autopilot-state.js

@@ -1,336 +0,0 @@
-/**
- * Autopilot Shared State Module
- *
- * Centralizes state management, validation, and task discovery
- * for both CLI command and MCP tools. Eliminates code duplication.
- *
- * ADR-072: Autopilot Integration
- * Security: Addresses prototype pollution, NaN bypass, input validation
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { randomUUID } from 'crypto';
-import { writeJsonFileAtomic } from './utils/json-file.js';
-// ── Constants ─────────────────────────────────────────────────
-export const STATE_DIR = '.monomind/data';
-export const STATE_FILE = `${STATE_DIR}/autopilot-state.json`;
-export const LOG_FILE = `${STATE_DIR}/autopilot-log.json`;
-/** Maximum entries kept in state.history (prevents unbounded growth) */
-const MAX_HISTORY_ENTRIES = 50;
-/** Maximum entries kept in the event log */
-const MAX_LOG_ENTRIES = 1000;
-/** Maximum bytes before refusing to load a state/log JSON file (10 MB) */
-const MAX_STATE_FILE_BYTES = 10 * 1024 * 1024;
-/** Allowlist for valid task sources */
-export const VALID_TASK_SOURCES = new Set(['team-tasks', 'swarm-tasks', 'file-checklist']);
-/** Terminal task statuses */
-export const TERMINAL_STATUSES = new Set(['completed', 'done', 'cancelled', 'skipped', 'failed']);
-// ── Validation Helpers ────────────────────────────────────────
-/**
- * Sanitize a parsed JSON object to prevent prototype pollution.
- * Removes __proto__, constructor, and prototype keys recursively.
- */
-function sanitizeObject(obj) {
-    if (obj === null || typeof obj !== 'object')
-        return obj;
-    if (Array.isArray(obj))
-        return obj.map(sanitizeObject);
-    const clean = {};
-    for (const key of Object.keys(obj)) {
-        if (key === '__proto__' || key === 'constructor' || key === 'prototype')
-            continue;
-        clean[key] = sanitizeObject(obj[key]);
-    }
-    return clean;
-}
-/**
- * Safe JSON.parse that prevents prototype pollution.
- */
-export function safeJsonParse(raw) {
-    return sanitizeObject(JSON.parse(raw));
-}
-/**
- * Validate and coerce a numeric parameter. Returns the default if
- * the input is NaN, undefined, or outside the allowed range.
- */
-export function validateNumber(value, min, max, defaultValue) {
-    if (value === undefined || value === null)
-        return defaultValue;
-    const num = Number(value);
-    if (!Number.isFinite(num))
-        return defaultValue;
-    return Math.min(Math.max(min, Math.round(num)), max);
-}
-/**
- * Validate task sources against the allowlist.
- * Returns only valid sources; falls back to defaults if none are valid.
- */
-export function validateTaskSources(sources) {
-    const defaults = ['team-tasks', 'swarm-tasks', 'file-checklist'];
-    if (!Array.isArray(sources))
-        return defaults;
-    const valid = sources
-        .filter((s) => typeof s === 'string')
-        .map(s => s.trim())
-        .filter(s => VALID_TASK_SOURCES.has(s));
-    return valid.length > 0 ? valid : defaults;
-}
-// ── State Management ──────────────────────────────────────────
-export function getDefaultState() {
-    return {
-        sessionId: randomUUID(),
-        enabled: false,
-        startTime: Date.now(),
-        iterations: 0,
-        maxIterations: 50,
-        timeoutMinutes: 240,
-        taskSources: ['team-tasks', 'swarm-tasks', 'file-checklist'],
-        lastCheck: null,
-        history: [],
-    };
-}
-export function loadState() {
-    const filePath = path.resolve(STATE_FILE);
-    const defaults = getDefaultState();
-    try {
-        if (fs.existsSync(filePath) && fs.statSync(filePath).size <= MAX_STATE_FILE_BYTES) {
-            const raw = safeJsonParse(fs.readFileSync(filePath, 'utf-8'));
-            const merged = { ...defaults, ...raw };
-            // Re-validate fields that could be tampered with
-            merged.maxIterations = validateNumber(merged.maxIterations, 1, 1000, 50);
-            merged.timeoutMinutes = validateNumber(merged.timeoutMinutes, 1, 1440, 240);
-            merged.iterations = validateNumber(merged.iterations, 0, 1000, 0);
-            merged.taskSources = validateTaskSources(merged.taskSources);
-            // Cap history to prevent unbounded growth
-            if (Array.isArray(merged.history) && merged.history.length > MAX_HISTORY_ENTRIES) {
-                merged.history = merged.history.slice(-MAX_HISTORY_ENTRIES);
-            }
-            return merged;
-        }
-    }
-    catch (e) {
-        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-            console.error('[autopilot-state] failed to load state file, using defaults:', e);
-    }
-    return defaults;
-}
-export function saveState(state) {
-    const dir = path.resolve(STATE_DIR);
-    if (!fs.existsSync(dir))
-        fs.mkdirSync(dir, { recursive: true });
-    // Cap history before saving
-    if (state.history.length > MAX_HISTORY_ENTRIES) {
-        state.history = state.history.slice(-MAX_HISTORY_ENTRIES);
-    }
-    // writeJsonFileAtomic uses a pid+timestamp-suffixed tmp path internally, so
-    // concurrent autopilot_enable/disable/reset calls won't collide.
-    writeJsonFileAtomic(path.resolve(STATE_FILE), state);
-}
-export function appendLog(entry) {
-    const filePath = path.resolve(LOG_FILE);
-    const dir = path.resolve(STATE_DIR);
-    if (!fs.existsSync(dir))
-        fs.mkdirSync(dir, { recursive: true });
-    // Append-only NDJSON: atomic at the OS level for individual lines, no
-    // read-modify-write race between concurrent MCP tool calls. Compaction is
-    // handled lazily by `compactLog()` which the daemon can call periodically.
-    // Previously this function did read → push → tmp-write → rename, which
-    // under concurrent autopilot_enable/disable/reset calls silently lost
-    // entries (last writer wins) and could truncate the log to a single entry
-    // if a peer crashed mid-write and the next caller's safeJsonParse threw.
-    try {
-        fs.appendFileSync(filePath, JSON.stringify(entry) + '\n', { flag: 'a' });
-    }
-    catch {
-        // Best-effort logging; do not throw from a non-critical observability path.
-    }
-    // Opportunistic compaction so the file doesn't grow without bound.
-    try {
-        const stat = fs.statSync(filePath);
-        if (stat.size > 4 * 1024 * 1024) {
-            compactLog(filePath);
-        }
-    }
-    catch { /* ignore */ }
-}
-/**
- * Compact NDJSON log down to MAX_LOG_ENTRIES. On parse failure for any line,
- * preserve the corrupt file aside (do not silently destroy data).
- */
-function compactLog(filePath) {
-    let lines;
-    try {
-        lines = fs.readFileSync(filePath, 'utf-8').split('\n').filter(l => l.trim().length > 0);
-    }
-    catch {
-        return;
-    }
-    const entries = [];
-    let corrupt = 0;
-    for (const line of lines) {
-        try {
-            const e = safeJsonParse(line);
-            if (e && typeof e === 'object')
-                entries.push(e);
-        }
-        catch {
-            corrupt++;
-        }
-    }
-    if (corrupt > 0) {
-        try {
-            fs.copyFileSync(filePath, `${filePath}.corrupt-${Date.now()}`);
-        }
-        catch { /* ignore */ }
-    }
-    const trimmed = entries.length > MAX_LOG_ENTRIES ? entries.slice(-MAX_LOG_ENTRIES) : entries;
-    const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-    fs.writeFileSync(tmp, trimmed.map(e => JSON.stringify(e)).join('\n') + '\n');
-    fs.renameSync(tmp, filePath);
-}
-export function loadLog() {
-    const filePath = path.resolve(LOG_FILE);
-    try {
-        if (fs.existsSync(filePath) && fs.statSync(filePath).size <= MAX_STATE_FILE_BYTES) {
-            const raw = fs.readFileSync(filePath, 'utf-8');
-            // Backward compatible: support both old JSON-array form and the new
-            // append-only NDJSON form. Prefer NDJSON if the file looks line-based.
-            const trimmed = raw.trim();
-            if (trimmed.startsWith('[')) {
-                const result = safeJsonParse(raw);
-                return Array.isArray(result) ? result : [];
-            }
-            const out = [];
-            for (const line of trimmed.split('\n')) {
-                if (!line)
-                    continue;
-                try {
-                    const entry = safeJsonParse(line);
-                    if (entry && typeof entry === 'object')
-                        out.push(entry);
-                }
-                catch { /* skip corrupt line */ }
-            }
-            return out;
-        }
-    }
-    catch (e) {
-        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-            console.error('[autopilot-state] failed to load log file, returning empty:', e);
-    }
-    return [];
-}
-// ── Task Discovery ────────────────────────────────────────────
-export function discoverTasks(sources) {
-    const tasks = [];
-    // Only process valid sources
-    const validSources = sources.filter(s => VALID_TASK_SOURCES.has(s));
-    for (const source of validSources) {
-        if (source === 'team-tasks') {
-            const tasksDir = path.join(os.homedir(), '.claude', 'tasks');
-            try {
-                if (fs.existsSync(tasksDir)) {
-                    const teams = fs.readdirSync(tasksDir, { withFileTypes: true });
-                    for (const team of teams) {
-                        if (!team.isDirectory())
-                            continue;
-                        const teamDir = path.join(tasksDir, team.name);
-                        const files = fs.readdirSync(teamDir).filter((f) => f.endsWith('.json'));
-                        for (const file of files) {
-                            try {
-                                const taskFilePath = path.join(teamDir, file);
-                                if (fs.statSync(taskFilePath).size > MAX_STATE_FILE_BYTES)
-                                    continue;
-                                const data = safeJsonParse(fs.readFileSync(taskFilePath, 'utf-8'));
-                                tasks.push({
-                                    id: String(data.id || file.replace('.json', '')),
-                                    subject: String(data.subject || data.title || file),
-                                    status: String(data.status || 'unknown'),
-                                    source: 'team-tasks',
-                                });
-                            }
-                            catch { /* skip individual file */ }
-                        }
-                    }
-                }
-            }
-            catch { /* skip source */ }
-        }
-        if (source === 'swarm-tasks') {
-            const swarmFile = path.resolve('.monomind/swarm-tasks.json');
-            try {
-                if (fs.existsSync(swarmFile) && fs.statSync(swarmFile).size <= MAX_STATE_FILE_BYTES) {
-                    const data = safeJsonParse(fs.readFileSync(swarmFile, 'utf-8'));
-                    const swarmTasks = Array.isArray(data) ? data : (data.tasks || []);
-                    for (const t of swarmTasks) {
-                        if (t && typeof t === 'object') {
-                            const task = t;
-                            tasks.push({
-                                id: String(task.id || task.taskId || `swarm-${tasks.length}`),
-                                subject: String(task.subject || task.description || task.name || 'Unnamed task'),
-                                status: String(task.status || 'unknown'),
-                                source: 'swarm-tasks',
-                            });
-                        }
-                    }
-                }
-            }
-            catch { /* skip source */ }
-        }
-        if (source === 'file-checklist') {
-            const checklistFile = path.resolve('.monomind/data/checklist.json');
-            try {
-                if (fs.existsSync(checklistFile) && fs.statSync(checklistFile).size <= MAX_STATE_FILE_BYTES) {
-                    const data = safeJsonParse(fs.readFileSync(checklistFile, 'utf-8'));
-                    const items = Array.isArray(data) ? data : (data.items || []);
-                    for (const item of items) {
-                        if (item && typeof item === 'object') {
-                            const i = item;
-                            tasks.push({
-                                id: String(i.id || `check-${tasks.length}`),
-                                subject: String(i.subject || i.text || i.description || 'Unnamed item'),
-                                status: String(i.status || (i.done ? 'completed' : 'pending')),
-                                source: 'file-checklist',
-                            });
-                        }
-                    }
-                }
-            }
-            catch { /* skip source */ }
-        }
-    }
-    return tasks;
-}
-// ── Progress Helpers ──────────────────────────────────────────
-export function isTerminal(status) {
-    return TERMINAL_STATUSES.has(status.toLowerCase());
-}
-export function getProgress(tasks) {
-    const completed = tasks.filter(t => isTerminal(t.status)).length;
-    const total = tasks.length;
-    const percent = total === 0 ? 100 : Math.round((completed / total) * 100);
-    const incomplete = tasks.filter(t => !isTerminal(t.status));
-    return { completed, total, percent, incomplete };
-}
-// ── Reward Calculation ────────────────────────────────────────
-export function calculateReward(iterations, durationMs) {
-    const iterFactor = (1 - iterations / (iterations + 10)) * 0.6;
-    const timeFactor = (1 - Math.min(durationMs / 3600000, 1)) * 0.4;
-    return Math.round((iterFactor + timeFactor) * 100) / 100;
-}
-// ── Learning Integration ──────────────────────────────────────
-export async function tryLoadLearning() {
-    try {
-        const modPath = 'agentic-flow/dist/coordination/autopilot-learning.js';
-        const mod = await import(/* webpackIgnore: true */ modPath).catch(() => null);
-        if (mod?.AutopilotLearning) {
-            const instance = new mod.AutopilotLearning();
-            if (await instance.initialize())
-                return instance;
-        }
-    }
-    catch { /* not available */ }
-    return null;
-}
-//# sourceMappingURL=autopilot-state.js.map

package/packages/@monomind/cli/dist/src/browser/action-builder/analyzer.d.ts

@@ -1,11 +0,0 @@
-import type { ActionDef } from './types.js';
-export declare function buildPrompt(task: string, domSnapshot: string): string;
-export declare function parseActionResponse(response: string): ActionDef;
-export declare function analyzeAndBuild(options: {
-    url: string;
-    task: string;
-    client: import('@monoes/monobrowse').CdpClient;
-    sessionId: string;
-    outputDir: string;
-}): Promise<ActionDef>;
-//# sourceMappingURL=analyzer.d.ts.map