open-multi-agent-kit 0.78.8 → 0.79.1

package/dist/util/cron-engine.js

@@ -1,227 +0,0 @@
-import { readFile, mkdir, readdir, writeFile } from "fs/promises";
-import { join } from "path";
-import { getProjectRoot, pathExists } from "./fs.js";
-const TICK_INTERVAL_MS = 15_000; // Check every 15 seconds
-const CRON_CONFIG_PATH = ".omk/cron.yml";
-const CRON_RUNS_DIR = ".omk/cron-runs";
-function normalizeJob(j, index) {
-    return {
-        name: j.name ?? `job-${index}`,
-        schedule: j.schedule ?? "@daily",
-        dagFile: j.dagFile ?? "",
-        concurrencyPolicy: j.concurrencyPolicy ?? "forbid",
-        enabled: j.enabled !== false,
-        catchup: j.catchup === true,
-        timeoutPreset: j.timeoutPreset,
-        lastRunAt: j.lastRunAt,
-        nextRunAt: j.nextRunAt,
-    };
-}
-export async function loadCronJobs() {
-    const root = getProjectRoot();
-    const configPath = join(root, CRON_CONFIG_PATH);
-    if (!(await pathExists(configPath)))
-        return [];
-    try {
-        const content = await readFile(configPath, "utf-8");
-        const yaml = await import("yaml");
-        const doc = yaml.parse(content);
-        if (!doc?.jobs)
-            return [];
-        return doc.jobs.map((j, index) => normalizeJob(j, index));
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        throw new Error(`Failed to load cron config ${configPath}: ${message}`);
-    }
-}
-export function mergeCronRuntimeState(loadedJobs, previousJobs, now = Date.now()) {
-    const previousByName = new Map(previousJobs.map((job) => [job.name, job]));
-    return loadedJobs.map((loaded, index) => {
-        const previous = previousByName.get(loaded.name);
-        const job = normalizeJob({
-            ...loaded,
-            lastRunAt: loaded.lastRunAt ?? previous?.lastRunAt,
-            nextRunAt: loaded.nextRunAt ?? previous?.nextRunAt,
-        }, index);
-        if (!job.nextRunAt && job.enabled) {
-            job.nextRunAt = computeNextRun(job.schedule, job.lastRunAt, job.catchup);
-        }
-        // If catchup is disabled and we missed the window, skip to next.
-        if (!job.catchup && job.nextRunAt && Date.parse(job.nextRunAt) < now - TICK_INTERVAL_MS * 2) {
-            job.nextRunAt = computeNextRun(job.schedule, new Date(now).toISOString(), false);
-        }
-        return job;
-    });
-}
-export function createCronEngine(handler, options = {}) {
-    const state = {
-        jobs: (options.jobs ?? []).map((job, index) => normalizeJob(job, index)),
-        activeRuns: new Map(),
-        timer: null,
-        handler,
-    };
-    async function refreshJobs() {
-        state.jobs = mergeCronRuntimeState(await loadCronJobs(), state.jobs, Date.now());
-    }
-    async function tick() {
-        await refreshJobs();
-        const now = Date.now();
-        for (const job of state.jobs) {
-            if (!job.enabled)
-                continue;
-            if (!job.nextRunAt) {
-                job.nextRunAt = computeNextRun(job.schedule, job.lastRunAt, job.catchup);
-                continue;
-            }
-            if (Date.parse(job.nextRunAt) > now)
-                continue;
-            // Concurrency check
-            const active = state.activeRuns.get(job.name);
-            if (active) {
-                if (job.concurrencyPolicy === "forbid") {
-                    continue;
-                }
-                if (job.concurrencyPolicy === "replace") {
-                    // We can't truly cancel the promise, but we detach tracking
-                    state.activeRuns.delete(job.name);
-                }
-                // "allow" proceeds
-            }
-            const runPromise = executeJob(job).then(() => undefined);
-            state.activeRuns.set(job.name, runPromise);
-            runPromise.finally(() => {
-                if (state.activeRuns.get(job.name) === runPromise) {
-                    state.activeRuns.delete(job.name);
-                }
-            });
-            job.lastRunAt = new Date().toISOString();
-            job.nextRunAt = computeNextRun(job.schedule, job.lastRunAt, job.catchup);
-        }
-    }
-    async function executeJob(job) {
-        const safeName = validateCronJobName(job.name);
-        const runId = `${job.name}-${Date.now()}`;
-        const root = getProjectRoot();
-        const logDir = join(root, CRON_RUNS_DIR, safeName);
-        await mkdir(logDir, { recursive: true });
-        const logPath = join(logDir, `${new Date().toISOString().replace(/[:.]/g, "-")}.json`);
-        const cronRun = {
-            jobName: job.name,
-            startedAt: new Date().toISOString(),
-            success: false,
-            runId,
-            logPath,
-        };
-        try {
-            await state.handler(job);
-            cronRun.success = true;
-            cronRun.completedAt = new Date().toISOString();
-        }
-        catch (err) {
-            cronRun.success = false;
-            cronRun.error = err instanceof Error ? err.message : String(err);
-            cronRun.completedAt = new Date().toISOString();
-        }
-        await writeFile(logPath, JSON.stringify(cronRun, null, 2));
-        return cronRun;
-    }
-    return {
-        start() {
-            if (state.timer)
-                return;
-            void tick();
-            state.timer = setInterval(() => void tick(), TICK_INTERVAL_MS);
-        },
-        stop() {
-            if (state.timer) {
-                clearInterval(state.timer);
-                state.timer = null;
-            }
-        },
-        listJobs() {
-            return state.jobs.map((j) => ({ ...j }));
-        },
-        async runJobNow(name) {
-            const job = state.jobs.find((j) => j.name === name);
-            if (!job)
-                return null;
-            return executeJob(job);
-        },
-        async getRuns(jobName) {
-            const root = getProjectRoot();
-            const logDir = join(root, CRON_RUNS_DIR, validateCronJobName(jobName));
-            if (!(await pathExists(logDir)))
-                return [];
-            const files = await readdir(logDir).catch(() => []);
-            const runs = [];
-            for (const file of files.filter((f) => f.endsWith(".json"))) {
-                try {
-                    const content = await readFile(join(logDir, file), "utf-8");
-                    runs.push(JSON.parse(content));
-                }
-                catch {
-                    // ignore malformed
-                }
-            }
-            return runs.sort((a, b) => Date.parse(a.startedAt) - Date.parse(b.startedAt));
-        },
-        enableJob(name) {
-            const job = state.jobs.find((j) => j.name === name);
-            if (job)
-                job.enabled = true;
-        },
-        disableJob(name) {
-            const job = state.jobs.find((j) => j.name === name);
-            if (job)
-                job.enabled = false;
-        },
-    };
-}
-export function validateCronJobName(name) {
-    const trimmed = name.trim();
-    if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/.test(trimmed) || trimmed.includes("..")) {
-        throw new Error(`Invalid cron job name: ${name}`);
-    }
-    return trimmed;
-}
-/**
- * Compute the next run time given a schedule expression.
- * Supports: standard cron 5-field, @yearly, @monthly, @weekly, @daily, @hourly,
- * and @every <duration> (e.g., @every 1m, @every 30m, @every 1h).
- */
-export function computeNextRun(schedule, lastRunAt, catchup = false) {
-    const lastRun = lastRunAt ? Date.parse(lastRunAt) : Date.now();
-    const base = catchup ? lastRun : Math.max(lastRun, Date.now());
-    // @every duration
-    const everyMatch = schedule.match(/^@every\s+(\d+)([smhd])$/i);
-    if (everyMatch) {
-        const value = Number.parseInt(everyMatch[1], 10);
-        const unit = everyMatch[2].toLowerCase();
-        const ms = unit === "s" ? value * 1000 :
-            unit === "m" ? value * 60_000 :
-                unit === "h" ? value * 3600_000 :
-                    value * 86400_000;
-        return new Date(base + ms).toISOString();
-    }
-    // Named schedules
-    const now = new Date(base);
-    switch (schedule) {
-        case "@yearly":
-        case "@annually":
-            return new Date(now.getFullYear() + 1, 0, 1, 0, 0, 0, 0).toISOString();
-        case "@monthly":
-            return new Date(now.getFullYear(), now.getMonth() + 1, 1, 0, 0, 0, 0).toISOString();
-        case "@weekly":
-            return new Date(now.getFullYear(), now.getMonth(), now.getDate() + (7 - now.getDay()), 0, 0, 0, 0).toISOString();
-        case "@daily":
-        case "@midnight":
-            return new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1, 0, 0, 0, 0).toISOString();
-        case "@hourly":
-            return new Date(now.getFullYear(), now.getMonth(), now.getDate(), now.getHours() + 1, 0, 0, 0).toISOString();
-        default:
-            // Simple 5-field cron: attempt to advance by 1 minute for basic cases
-            // Full cron parser is out of scope; fallback to +1 hour for unrecognized
-            return new Date(base + 3600_000).toISOString();
-    }
-}

package/dist/util/events-logger.d.ts

@@ -1,30 +0,0 @@
-export type ReplayEventType = "replay-start" | "replay-end" | "node-start" | "node-complete" | "node-fallback" | "state-change";
-export type TelemetryEventType = ReplayEventType | "lane.started" | "lane.activity" | "lane.heartbeat" | "lane.completed" | "lane.failed" | "lane.stalled" | "agent.spawned" | "tool.started" | "tool.completed" | "mcp.started" | "mcp.completed" | "mcp.failed" | "hook.started" | "hook.completed" | "provider.route" | "provider.fallback" | "provider.request.started" | "provider.request.completed" | "provider.request.failed" | "provider.advisory.started" | "provider.advisory.completed" | "provider.advisory.failed" | "evidence.result";
-export interface TelemetryEvent {
-    schemaVersion: "telemetry.v1";
-    type: TelemetryEventType;
-    timestamp: string;
-    seq: number;
-    runId: string;
-    nodeId?: string;
-    laneId?: string;
-    agentId?: string;
-    toolName?: string;
-    provider?: string;
-    status?: string;
-    data?: Record<string, unknown>;
-}
-export type ReplayEvent = TelemetryEvent;
-export interface ReadEventsOptions {
-    afterSeq?: number;
-    limit?: number;
-}
-type EventInput = Omit<TelemetryEvent, "schemaVersion" | "timestamp" | "seq"> & {
-    schemaVersion?: "telemetry.v1";
-    timestamp?: string;
-    seq?: number;
-};
-export declare function appendEvent(runDir: string, event: EventInput): Promise<void>;
-export declare function readEvents(runDir: string): Promise<ReplayEvent[]>;
-export declare function tailEvents(runDir: string, options?: ReadEventsOptions): Promise<ReplayEvent[]>;
-export {};

package/dist/util/events-logger.js

@@ -1,135 +0,0 @@
-import { appendFile, readFile } from "fs/promises";
-import { join } from "path";
-import { redactSecrets } from "../orchestration/state-persister.js";
-const MAX_STRING_LENGTH = 500;
-const MAX_ARRAY_ITEMS = 20;
-const MAX_OBJECT_KEYS = 40;
-const MAX_DEPTH = 4;
-const seqByRunDir = new Map();
-const appendQueueByRunDir = new Map();
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function shouldRedactPayloadKey(key) {
-    const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, "");
-    return normalized === "env" ||
-        normalized === "headers" ||
-        normalized === "header" ||
-        normalized === "args" ||
-        normalized === "arguments" ||
-        normalized === "toolargs" ||
-        normalized === "rawargs" ||
-        normalized === "stdout" ||
-        normalized === "stderr" ||
-        normalized === "rawstdout" ||
-        normalized === "rawstderr";
-}
-function boundString(value) {
-    return value.length > MAX_STRING_LENGTH
-        ? `${value.slice(0, MAX_STRING_LENGTH)}…[truncated ${value.length - MAX_STRING_LENGTH} chars]`
-        : value;
-}
-function sanitizeTelemetryValue(value, depth = 0, key) {
-    if (key && shouldRedactPayloadKey(key))
-        return "[redacted]";
-    const redacted = redactSecrets(value);
-    if (typeof redacted === "string")
-        return boundString(redacted);
-    if (typeof redacted !== "object" || redacted === null)
-        return redacted;
-    if (depth >= MAX_DEPTH)
-        return "[truncated-depth]";
-    if (Array.isArray(redacted)) {
-        const out = redacted
-            .slice(0, MAX_ARRAY_ITEMS)
-            .map((item) => sanitizeTelemetryValue(item, depth + 1));
-        if (redacted.length > MAX_ARRAY_ITEMS) {
-            out.push(`[truncated ${redacted.length - MAX_ARRAY_ITEMS} items]`);
-        }
-        return out;
-    }
-    const out = {};
-    const entries = Object.entries(redacted);
-    for (const [entryKey, entryValue] of entries.slice(0, MAX_OBJECT_KEYS)) {
-        out[entryKey] = sanitizeTelemetryValue(entryValue, depth + 1, entryKey);
-    }
-    if (entries.length > MAX_OBJECT_KEYS) {
-        out.truncatedKeys = entries.length - MAX_OBJECT_KEYS;
-    }
-    return out;
-}
-function sanitizeTelemetryEvent(event, seq) {
-    const sanitized = sanitizeTelemetryValue(event);
-    const record = isRecord(sanitized) ? sanitized : {};
-    return {
-        schemaVersion: "telemetry.v1",
-        type: String(record.type ?? event.type),
-        timestamp: typeof record.timestamp === "string" ? record.timestamp : new Date().toISOString(),
-        seq,
-        runId: String(record.runId ?? event.runId),
-        nodeId: typeof record.nodeId === "string" ? record.nodeId : undefined,
-        laneId: typeof record.laneId === "string" ? record.laneId : undefined,
-        agentId: typeof record.agentId === "string" ? record.agentId : undefined,
-        toolName: typeof record.toolName === "string" ? record.toolName : undefined,
-        provider: typeof record.provider === "string" ? record.provider : undefined,
-        status: typeof record.status === "string" ? record.status : undefined,
-        data: isRecord(record.data) ? record.data : undefined,
-    };
-}
-async function nextSeq(runDir, explicitSeq) {
-    if (typeof explicitSeq === "number" && Number.isFinite(explicitSeq) && explicitSeq > 0) {
-        seqByRunDir.set(runDir, explicitSeq);
-        return explicitSeq;
-    }
-    const current = seqByRunDir.get(runDir);
-    if (current != null) {
-        const next = current + 1;
-        seqByRunDir.set(runDir, next);
-        return next;
-    }
-    const events = await readEvents(runDir);
-    const maxSeq = events.reduce((max, event) => Math.max(max, event.seq || 0), 0);
-    const next = maxSeq + 1;
-    seqByRunDir.set(runDir, next);
-    return next;
-}
-export async function appendEvent(runDir, event) {
-    const previous = appendQueueByRunDir.get(runDir) ?? Promise.resolve();
-    const write = previous.then(async () => {
-        const seq = await nextSeq(runDir, event.seq);
-        const line = JSON.stringify(sanitizeTelemetryEvent({ ...event, timestamp: event.timestamp ?? new Date().toISOString() }, seq)) + "\n";
-        await appendFile(join(runDir, "events.jsonl"), line, "utf-8");
-    });
-    appendQueueByRunDir.set(runDir, write.catch(() => { }));
-    await write;
-}
-export async function readEvents(runDir) {
-    try {
-        const content = await readFile(join(runDir, "events.jsonl"), "utf-8");
-        const events = [];
-        for (const line of content.split("\n")) {
-            if (!line.trim())
-                continue;
-            try {
-                const parsed = JSON.parse(line);
-                const seq = typeof parsed.seq === "number" && Number.isFinite(parsed.seq) ? parsed.seq : events.length + 1;
-                events.push(sanitizeTelemetryEvent(parsed, seq));
-            }
-            catch {
-                // Keep append-only logs readable even if one line is corrupt.
-            }
-        }
-        return events;
-    }
-    catch {
-        return [];
-    }
-}
-export async function tailEvents(runDir, options = {}) {
-    const afterSeq = options.afterSeq ?? 0;
-    const filtered = (await readEvents(runDir)).filter((event) => event.seq > afterSeq);
-    if (options.limit != null && options.limit >= 0) {
-        return filtered.slice(-options.limit);
-    }
-    return filtered;
-}

package/dist/util/execution-selection.d.ts

@@ -1,13 +0,0 @@
-import type { ExecutionPromptPolicy, ExecutionSelectionDecision, ExecutionStrategy, UserIntent } from "../contracts/orchestration.js";
-export declare const EXECUTION_PROMPT_POLICIES: readonly ExecutionPromptPolicy[];
-export declare const EXECUTION_PROMPT_CHOICES: readonly ExecutionStrategy[];
-export declare function normalizeExecutionPromptPolicy(value: string | undefined): ExecutionPromptPolicy | undefined;
-export declare function parseExecutionPromptPolicy(value: string | undefined, sourceLabel?: string): ExecutionPromptPolicy | undefined;
-export declare function isNonTrivialIntent(intent: UserIntent): boolean;
-export declare function resolveExecutionSelectionDecision(input: {
-    cliValue?: string;
-    configValue?: string | ExecutionPromptPolicy;
-    intent: UserIntent;
-    isTTY: boolean;
-}): ExecutionSelectionDecision;
-export declare function resolvePromptExecutionDecision(base: ExecutionSelectionDecision, strategy: Exclude<ExecutionStrategy, "prompt">): ExecutionSelectionDecision;

package/dist/util/execution-selection.js

@@ -1,82 +0,0 @@
-import { UsageError } from "./cli-contract.js";
-export const EXECUTION_PROMPT_POLICIES = [
-    "ask",
-    "auto",
-    "parallel",
-    "sequential",
-];
-export const EXECUTION_PROMPT_CHOICES = [
-    "parallel",
-    "sequential",
-    "plan-only",
-];
-export function normalizeExecutionPromptPolicy(value) {
-    const normalized = value?.trim().toLowerCase();
-    if (!normalized)
-        return undefined;
-    if (normalized === "one-by-one" || normalized === "one_by_one" || normalized === "serial")
-        return "sequential";
-    if (normalized === "agents" || normalized === "subagents")
-        return "parallel";
-    if (EXECUTION_PROMPT_POLICIES.includes(normalized)) {
-        return normalized;
-    }
-    return undefined;
-}
-export function parseExecutionPromptPolicy(value, sourceLabel = "--execution") {
-    if (value === undefined || value.trim() === "")
-        return undefined;
-    const policy = normalizeExecutionPromptPolicy(value);
-    if (policy)
-        return policy;
-    throw new UsageError(`Invalid ${sourceLabel}: ${value}. Expected ask | auto | parallel | sequential.`);
-}
-export function isNonTrivialIntent(intent) {
-    return intent.complexity !== "simple" || intent.estimatedWorkers > 1 || intent.parallelizable === true;
-}
-export function resolveExecutionSelectionDecision(input) {
-    const cliPolicy = parseExecutionPromptPolicy(input.cliValue, "--execution");
-    const configPolicy = typeof input.configValue === "string"
-        ? parseExecutionPromptPolicy(input.configValue, "execution config")
-        : input.configValue;
-    const policy = cliPolicy ?? configPolicy ?? "ask";
-    const source = cliPolicy ? "cli" : configPolicy ? "config" : "default";
-    const isNonTrivial = isNonTrivialIntent(input.intent);
-    if (policy === "parallel") {
-        return makeDecision(policy, source, "parallel", "execution policy forces parallel agents", input.isTTY, isNonTrivial);
-    }
-    if (policy === "sequential") {
-        return makeDecision(policy, source, "sequential", "execution policy forces one-by-one execution", input.isTTY, isNonTrivial);
-    }
-    if (policy === "auto") {
-        const strategy = shouldAutoParallel(input.intent) ? "parallel" : "sequential";
-        return makeDecision(policy, source, strategy, strategy === "parallel"
-            ? "auto selected parallel agents for a non-trivial or parallelizable intent"
-            : "auto selected one-by-one execution for a simple intent", input.isTTY, isNonTrivial);
-    }
-    if (input.isTTY && isNonTrivial) {
-        return makeDecision(policy, source, "prompt", "TTY non-trivial intent must ask before execution", input.isTTY, isNonTrivial);
-    }
-    const strategy = isNonTrivial ? "parallel" : "sequential";
-    return makeDecision(policy, source, strategy, isNonTrivial
-        ? "non-TTY ask policy cannot prompt, so complex work defaults to parallel agents"
-        : "simple intent can run one by one without prompting", input.isTTY, isNonTrivial);
-}
-export function resolvePromptExecutionDecision(base, strategy) {
-    return {
-        ...base,
-        source: "prompt",
-        strategy,
-        reason: strategy === "parallel"
-            ? "user selected parallel agents"
-            : strategy === "sequential"
-                ? "user selected one-by-one execution"
-                : "user selected plan-only",
-    };
-}
-function shouldAutoParallel(intent) {
-    return intent.complexity === "complex" || intent.estimatedWorkers > 1 || intent.parallelizable === true;
-}
-function makeDecision(policy, source, strategy, reason, isTTY, isNonTrivial) {
-    return { policy, source, strategy, reason, isTTY, isNonTrivial };
-}

package/dist/util/first-run-star.d.ts

@@ -1,58 +0,0 @@
-export type StarPromptResult = "yes" | "no" | "seen" | "skipped" | "error";
-export interface StarPromptState {
-    promptedAt: string;
-    answer: "yes" | "no";
-    version: string;
-    repoUrl: string;
-    action: "github-star";
-    starred?: boolean;
-    starError?: string;
-}
-export interface StarPromptOptions {
-    version: string;
-    repoUrl?: string;
-    homeDir?: string;
-    env?: NodeJS.ProcessEnv;
-    argv?: string[];
-    stdin?: {
-        isTTY?: boolean;
-    };
-    stdout?: {
-        isTTY?: boolean;
-    };
-    commandName?: string;
-    prompt?: (repoUrl: string) => Promise<boolean>;
-    starRepo?: (repoUrl: string) => Promise<void> | void;
-    openBrowser?: typeof openRepoInBrowser;
-    now?: () => Date;
-}
-export declare function getStarPromptStatePath(homeDir?: string): string;
-export declare function isStarPromptEligible(options?: Omit<StarPromptOptions, "version" | "prompt" | "openUrl" | "now"> & {
-    allowChat?: boolean;
-}): boolean;
-export declare function readStarPromptState(homeDir?: string): Promise<StarPromptState | null>;
-export declare function maybeAskForGitHubStar(options: StarPromptOptions & {
-    allowChat?: boolean;
-}): Promise<StarPromptResult>;
-export declare function maybeAskForGitHubStarAtChatStart(options: StarPromptOptions): Promise<StarPromptResult>;
-export interface StarPromptAfterCommandOptions extends StarPromptOptions {
-    commandName: string;
-}
-export declare function maybeAskForGitHubStarAfterCommand(options: StarPromptAfterCommandOptions): Promise<StarPromptResult>;
-export interface StarPromptSummary {
-    answered: boolean;
-    starred?: boolean;
-    starError?: string;
-}
-export declare function getStarPromptSummary(homeDir?: string): Promise<StarPromptSummary | null>;
-export declare function parseGitHubRepoSlug(repoUrl: string): string | null;
-export declare function checkGhAuth(): Promise<void>;
-export declare function starGitHubRepo(repoUrl: string): Promise<void>;
-export interface OpenRepoInBrowserOptions {
-    spawnFn?: typeof import("child_process").spawn;
-    platform?: NodeJS.Platform;
-    display?: string;
-    isTTY?: boolean;
-    env?: NodeJS.ProcessEnv;
-}
-export declare function openRepoInBrowser(repoUrl: string, opts?: OpenRepoInBrowserOptions): Promise<boolean>;