monomind 1.9.16 → 1.10.0

package/packages/@monomind/cli/dist/src/context/project-conventions-provider.js

@@ -1,19 +0,0 @@
-/**
- * ProjectConventionsProvider — loads project-level conventions (e.g. from
- * CLAUDE.md or a config file) and injects them as a required context section.
- */
-import { BaseContextProvider } from './context-provider.js';
-export class ProjectConventionsProvider extends BaseContextProvider {
-    loader;
-    name = 'project-conventions';
-    priority = 100;
-    required = true;
-    constructor(loader) {
-        super();
-        this.loader = loader;
-    }
-    async provide(_ctx) {
-        return this.loader();
-    }
-}
-//# sourceMappingURL=project-conventions-provider.js.map

package/packages/@monomind/cli/dist/src/context/prompt-assembler.d.ts

@@ -1,26 +0,0 @@
-/**
- * PromptAssembler — collects context sections from multiple providers,
- * prioritises them within a token budget, and concatenates the result
- * with the base prompt.
- */
-import type { ContextProvider, RunContext } from './context-provider.js';
-export interface AssemblyConfig {
-    maxTotalTokens?: number;
-    basePromptTokens: number;
-    providers: ContextProvider[];
-}
-export interface AssembledPrompt {
-    content: string;
-    sectionsIncluded: string[];
-    sectionsTruncated: string[];
-    sectionsDropped: string[];
-    totalTokenEstimate: number;
-}
-export declare class PromptAssembler {
-    private readonly maxTotalTokens;
-    private readonly basePromptTokens;
-    private readonly providers;
-    constructor(config: AssemblyConfig);
-    assemble(basePrompt: string, ctx: RunContext): Promise<AssembledPrompt>;
-}
-//# sourceMappingURL=prompt-assembler.d.ts.map

package/packages/@monomind/cli/dist/src/context/prompt-assembler.js

@@ -1,93 +0,0 @@
-/**
- * PromptAssembler — collects context sections from multiple providers,
- * prioritises them within a token budget, and concatenates the result
- * with the base prompt.
- */
-const DEFAULT_MAX_TOTAL_TOKENS = 6000;
-const CHARS_PER_TOKEN = 4;
-const SECTION_SEPARATOR = '\n\n---\n\n';
-function estimateTokens(text) {
-    return Math.ceil(text.length / CHARS_PER_TOKEN);
-}
-function truncateToTokens(text, maxTokens) {
-    const maxChars = maxTokens * CHARS_PER_TOKEN;
-    if (text.length <= maxChars) {
-        return text;
-    }
-    return text.slice(0, maxChars);
-}
-export class PromptAssembler {
-    maxTotalTokens;
-    basePromptTokens;
-    providers;
-    constructor(config) {
-        this.maxTotalTokens = config.maxTotalTokens ?? DEFAULT_MAX_TOTAL_TOKENS;
-        this.basePromptTokens = config.basePromptTokens;
-        this.providers = config.providers;
-    }
-    async assemble(basePrompt, ctx) {
-        // 1. Call all providers concurrently
-        const settled = await Promise.allSettled(this.providers.map(async (p) => {
-            const content = await p.provide(ctx);
-            return {
-                name: p.name,
-                content,
-                tokens: estimateTokens(content),
-                priority: p.priority,
-                required: p.required,
-            };
-        }));
-        // 2. Filter out rejected / empty results
-        const sections = [];
-        for (const result of settled) {
-            if (result.status === 'fulfilled' && result.value.content.length > 0) {
-                sections.push(result.value);
-            }
-        }
-        // 3. Sort by priority descending
-        sections.sort((a, b) => b.priority - a.priority);
-        // 4. Fit within budget
-        const budget = this.maxTotalTokens - this.basePromptTokens;
-        let remaining = budget;
-        const included = [];
-        const truncated = [];
-        const dropped = [];
-        for (const section of sections) {
-            if (section.tokens <= remaining) {
-                // Fits entirely
-                included.push(section);
-                remaining -= section.tokens;
-            }
-            else if (section.required) {
-                // Required but exceeds remaining — truncate to fit
-                const truncatedContent = truncateToTokens(section.content, remaining);
-                included.push({
-                    ...section,
-                    content: truncatedContent,
-                    tokens: estimateTokens(truncatedContent),
-                });
-                truncated.push(section.name);
-                remaining -= estimateTokens(truncatedContent);
-            }
-            else {
-                // Optional and doesn't fit — drop
-                dropped.push(section.name);
-            }
-        }
-        // 5. Build final prompt: context sections first, then base prompt
-        const contextParts = included.map((s) => s.content);
-        const assembled = contextParts.length > 0
-            ? contextParts.join(SECTION_SEPARATOR) +
-                SECTION_SEPARATOR +
-                basePrompt
-            : basePrompt;
-        return {
-            content: assembled,
-            sectionsIncluded: included.map((s) => s.name),
-            sectionsTruncated: truncated,
-            sectionsDropped: dropped,
-            totalTokenEstimate: estimateTokens(assembled),
-        };
-    }
-}
-//# sourceMappingURL=prompt-assembler.js.map

package/packages/@monomind/cli/dist/src/context/task-history-provider.d.ts

@@ -1,24 +0,0 @@
-/**
- * TaskHistoryProvider — searches memory for previously completed tasks that
- * are similar to the current one and formats them as markdown context.
- */
-import { BaseContextProvider, type RunContext } from './context-provider.js';
-export interface SearchResult {
-    metadata: Record<string, unknown>;
-    value: string;
-    score: number;
-}
-export type SearchFn = (query: string, options: {
-    namespace: string;
-    limit: number;
-    minScore: number;
-}) => Promise<SearchResult[]>;
-export declare class TaskHistoryProvider extends BaseContextProvider {
-    private readonly search;
-    readonly name: "task-history";
-    readonly priority = 50;
-    readonly maxTokens = 600;
-    constructor(search: SearchFn);
-    provide(ctx: RunContext): Promise<string>;
-}
-//# sourceMappingURL=task-history-provider.d.ts.map

package/packages/@monomind/cli/dist/src/context/task-history-provider.js

@@ -1,32 +0,0 @@
-/**
- * TaskHistoryProvider — searches memory for previously completed tasks that
- * are similar to the current one and formats them as markdown context.
- */
-import { BaseContextProvider } from './context-provider.js';
-export class TaskHistoryProvider extends BaseContextProvider {
-    search;
-    name = 'task-history';
-    priority = 50;
-    maxTokens = 600;
-    constructor(search) {
-        super();
-        this.search = search;
-    }
-    async provide(ctx) {
-        const results = await this.search(ctx.taskDescription, {
-            namespace: 'tasks',
-            limit: 5,
-            minScore: 0.6,
-        });
-        if (!results || results.length === 0) {
-            return '';
-        }
-        const lines = ['**Similar past tasks:**'];
-        for (const r of results) {
-            const label = r.metadata?.['title'] ?? r.value.slice(0, 80);
-            lines.push(`- (${(r.score * 100).toFixed(0)}%) ${label}`);
-        }
-        return this.truncateToTokens(lines.join('\n'), this.maxTokens);
-    }
-}
-//# sourceMappingURL=task-history-provider.js.map

package/packages/@monomind/cli/dist/src/context/user-preferences-provider.d.ts

@@ -1,14 +0,0 @@
-/**
- * UserPreferencesProvider — fetches user-level preferences for the active
- * session and formats them as a bullet list for injection into the prompt.
- */
-import { BaseContextProvider, type RunContext } from './context-provider.js';
-export type PreferencesGetter = (sessionId: string) => Promise<Record<string, string>>;
-export declare class UserPreferencesProvider extends BaseContextProvider {
-    private readonly getter;
-    readonly name: "user-preferences";
-    readonly priority = 90;
-    constructor(getter: PreferencesGetter);
-    provide(ctx: RunContext): Promise<string>;
-}
-//# sourceMappingURL=user-preferences-provider.d.ts.map

package/packages/@monomind/cli/dist/src/context/user-preferences-provider.js

@@ -1,27 +0,0 @@
-/**
- * UserPreferencesProvider — fetches user-level preferences for the active
- * session and formats them as a bullet list for injection into the prompt.
- */
-import { BaseContextProvider } from './context-provider.js';
-export class UserPreferencesProvider extends BaseContextProvider {
-    getter;
-    name = 'user-preferences';
-    priority = 90;
-    constructor(getter) {
-        super();
-        this.getter = getter;
-    }
-    async provide(ctx) {
-        const prefs = await this.getter(ctx.sessionId);
-        const entries = Object.entries(prefs);
-        if (entries.length === 0) {
-            return '';
-        }
-        const lines = ['**User preferences:**'];
-        for (const [key, value] of entries) {
-            lines.push(`- ${key}: ${value}`);
-        }
-        return this.truncateToTokens(lines.join('\n'), this.maxTokens);
-    }
-}
-//# sourceMappingURL=user-preferences-provider.js.map

package/packages/@monomind/cli/dist/src/dlq/dlq-reader.d.ts

@@ -1,31 +0,0 @@
-/**
- * DLQ Reader (Task 37)
- *
- * Reads, filters, and purges DLQ entries from JSONL storage.
- */
-import type { DLQEntry, DLQEntryStatus } from '../../../shared/src/types/dlq.js';
-/** Options for listing DLQ entries */
-export interface DLQListOptions {
-    status?: DLQEntryStatus;
-    toolName?: string;
-    agentId?: string;
-    olderThanDays?: number;
-    limit?: number;
-}
-export declare class DLQReader {
-    private readonly filePath;
-    constructor(filePath: string);
-    /** Read all entries from the JSONL file with a hard size cap.
-     * The DLQ is append-only with no rotation — without this guard a long-running
-     * process can grow the file to GBs and OOM on every list/get/purge call. */
-    private readAll;
-    /** Write all entries back (used for purge) — uses unique tmp filename to avoid concurrent writer collisions */
-    private writeAll;
-    /** List entries with optional filters (defaults to status='pending') */
-    list(opts?: DLQListOptions): DLQEntry[];
-    /** Get a single entry by messageId */
-    get(messageId: string): DLQEntry | null;
-    /** Purge old pending entries (mark as 'purged') */
-    purge(olderThanDays: number): number;
-}
-//# sourceMappingURL=dlq-reader.d.ts.map

package/packages/@monomind/cli/dist/src/dlq/dlq-reader.js

@@ -1,81 +0,0 @@
-/**
- * DLQ Reader (Task 37)
- *
- * Reads, filters, and purges DLQ entries from JSONL storage.
- */
-import { randomUUID } from 'crypto';
-import { existsSync, readFileSync, writeFileSync, renameSync, statSync, unlinkSync } from 'fs';
-import { parseJsonl } from '../utils/parse-jsonl.js';
-export class DLQReader {
-    filePath;
-    constructor(filePath) {
-        this.filePath = filePath;
-    }
-    /** Read all entries from the JSONL file with a hard size cap.
-     * The DLQ is append-only with no rotation — without this guard a long-running
-     * process can grow the file to GBs and OOM on every list/get/purge call. */
-    readAll() {
-        if (!existsSync(this.filePath))
-            return [];
-        const stat = statSync(this.filePath);
-        if (stat.size > 256 * 1024 * 1024) {
-            throw new Error(`DLQ file exceeds 256MB (${stat.size} bytes). Run rotation/cleanup.`);
-        }
-        const raw = readFileSync(this.filePath, 'utf-8');
-        return parseJsonl(raw);
-    }
-    /** Write all entries back (used for purge) — uses unique tmp filename to avoid concurrent writer collisions */
-    writeAll(entries) {
-        const content = entries.map((e) => JSON.stringify(e)).join('\n') + (entries.length ? '\n' : '');
-        const tmp = `${this.filePath}.${randomUUID()}.tmp`;
-        try {
-            writeFileSync(tmp, content, 'utf-8');
-            renameSync(tmp, this.filePath);
-        }
-        catch (err) {
-            try {
-                unlinkSync(tmp);
-            }
-            catch { /* ignore cleanup failure */ }
-            throw err;
-        }
-    }
-    /** List entries with optional filters (defaults to status='pending') */
-    list(opts = {}) {
-        const status = opts.status ?? 'pending';
-        let entries = this.readAll().filter((e) => e.status === status);
-        if (opts.toolName) {
-            entries = entries.filter((e) => e.toolName === opts.toolName);
-        }
-        if (opts.agentId) {
-            entries = entries.filter((e) => e.agentId === opts.agentId);
-        }
-        if (opts.olderThanDays !== undefined) {
-            const cutoff = Date.now() - opts.olderThanDays * 24 * 60 * 60 * 1000;
-            entries = entries.filter((e) => new Date(e.createdAt).getTime() < cutoff);
-        }
-        if (opts.limit !== undefined) {
-            entries = entries.slice(0, opts.limit);
-        }
-        return entries;
-    }
-    /** Get a single entry by messageId */
-    get(messageId) {
-        return this.readAll().find((e) => e.messageId === messageId) ?? null;
-    }
-    /** Purge old pending entries (mark as 'purged') */
-    purge(olderThanDays) {
-        const entries = this.readAll();
-        const cutoff = Date.now() - olderThanDays * 24 * 60 * 60 * 1000;
-        let count = 0;
-        for (const entry of entries) {
-            if (entry.status === 'pending' && new Date(entry.createdAt).getTime() < cutoff) {
-                entry.status = 'purged';
-                count++;
-            }
-        }
-        this.writeAll(entries);
-        return count;
-    }
-}
-//# sourceMappingURL=dlq-reader.js.map

package/packages/@monomind/cli/dist/src/dlq/dlq-replayer.d.ts

@@ -1,27 +0,0 @@
-/**
- * DLQ Replayer (Task 37)
- *
- * Replays dead-letter queue entries by re-invoking the original tool call.
- *
- * CONCURRENCY: Uses append-only status records to avoid racing with DLQWriter.enqueue().
- * A status record `{ _statusFor, status, replayedAt, replayResult }` is appended after
- * replay. readAll() merges status records into the base entries — the last status wins.
- * Compaction rewrites the file when status records exceed 20% of total lines.
- */
-import type { DLQReplayResult } from '../../../shared/src/types/dlq.js';
-/** A function that attempts to call a tool with the original payload */
-export type ToolCaller = (toolName: string, payload: unknown) => Promise<void>;
-export declare class DLQReplayer {
-    private readonly filePath;
-    private readonly toolCaller;
-    constructor(filePath: string, toolCaller: ToolCaller);
-    /** Read all lines, merge status records into entries. Last status wins. */
-    private readAll;
-    /** Append a status-change record — never touches existing lines, safe alongside DLQWriter. */
-    private appendStatus;
-    /** Compact: rewrite file with merged entries only, removing status records. */
-    private compact;
-    /** Replay a single DLQ entry by messageId */
-    replay(messageId: string): Promise<DLQReplayResult>;
-}
-//# sourceMappingURL=dlq-replayer.d.ts.map

package/packages/@monomind/cli/dist/src/dlq/dlq-replayer.js

@@ -1,90 +0,0 @@
-/**
- * DLQ Replayer (Task 37)
- *
- * Replays dead-letter queue entries by re-invoking the original tool call.
- *
- * CONCURRENCY: Uses append-only status records to avoid racing with DLQWriter.enqueue().
- * A status record `{ _statusFor, status, replayedAt, replayResult }` is appended after
- * replay. readAll() merges status records into the base entries — the last status wins.
- * Compaction rewrites the file when status records exceed 20% of total lines.
- */
-import { appendFileSync, existsSync, readFileSync, renameSync, statSync, writeFileSync } from 'fs';
-export class DLQReplayer {
-    filePath;
-    toolCaller;
-    constructor(filePath, toolCaller) {
-        this.filePath = filePath;
-        this.toolCaller = toolCaller;
-    }
-    /** Read all lines, merge status records into entries. Last status wins. */
-    readAll() {
-        if (!existsSync(this.filePath))
-            return { entries: [], rawLineCount: 0 };
-        const stat = statSync(this.filePath);
-        if (stat.size > 256 * 1024 * 1024) {
-            throw new Error(`DLQ file exceeds 256MB (${stat.size} bytes). Run rotation/cleanup.`);
-        }
-        const raw = readFileSync(this.filePath, 'utf-8').trim();
-        if (!raw)
-            return { entries: [], rawLineCount: 0 };
-        const lines = raw.split('\n').filter(Boolean);
-        const statusMap = new Map();
-        const baseEntries = [];
-        for (const line of lines) {
-            try {
-                const parsed = JSON.parse(line);
-                if (parsed._statusFor) {
-                    statusMap.set(parsed._statusFor, parsed);
-                }
-                else {
-                    baseEntries.push(parsed);
-                }
-            }
-            catch { /* skip malformed lines */ }
-        }
-        const entries = baseEntries.map((e) => {
-            const s = statusMap.get(e.messageId);
-            return s ? { ...e, status: s.status, replayedAt: s.replayedAt, replayResult: s.replayResult } : e;
-        });
-        return { entries, rawLineCount: lines.length };
-    }
-    /** Append a status-change record — never touches existing lines, safe alongside DLQWriter. */
-    appendStatus(record) {
-        appendFileSync(this.filePath, JSON.stringify(record) + '\n', 'utf-8');
-    }
-    /** Compact: rewrite file with merged entries only, removing status records. */
-    compact(entries) {
-        const content = entries.map((e) => JSON.stringify(e)).join('\n') + (entries.length ? '\n' : '');
-        const tmp = `${this.filePath}.${process.pid}.${Date.now()}.tmp`;
-        writeFileSync(tmp, content, 'utf-8');
-        renameSync(tmp, this.filePath);
-    }
-    /** Replay a single DLQ entry by messageId */
-    async replay(messageId) {
-        const { entries, rawLineCount } = this.readAll();
-        const entry = entries.find((e) => e.messageId === messageId);
-        if (!entry) {
-            throw new Error(`DLQ entry not found: ${messageId}`);
-        }
-        if (entry.status !== 'pending') {
-            throw new Error(`DLQ entry is not pending: ${messageId} (status=${entry.status})`);
-        }
-        const now = new Date().toISOString();
-        try {
-            await this.toolCaller(entry.toolName, entry.originalPayload);
-            this.appendStatus({ _statusFor: messageId, status: 'replayed', replayedAt: now, replayResult: 'success' });
-            // Compact when status records inflate file by >20%
-            if (rawLineCount > 0 && (rawLineCount - entries.length) / rawLineCount > 0.2) {
-                const merged = entries.map((e) => e.messageId === messageId ? { ...e, status: 'replayed', replayedAt: now, replayResult: 'success' } : e);
-                this.compact(merged);
-            }
-            return { messageId, success: true, replayedAt: now };
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            this.appendStatus({ _statusFor: messageId, status: 'pending', replayedAt: now, replayResult: 'failed_again' });
-            return { messageId, success: false, errorMessage, replayedAt: now };
-        }
-    }
-}
-//# sourceMappingURL=dlq-replayer.js.map

package/packages/@monomind/cli/dist/src/dlq/dlq-writer.d.ts

@@ -1,24 +0,0 @@
-/**
- * DLQ Writer (Task 37)
- *
- * JSONL append-only storage for dead-letter queue entries.
- */
-import type { DLQEntry, DeliveryAttempt } from '../../../shared/src/types/dlq.js';
-/** Input for enqueue — caller provides these fields */
-export interface EnqueueInput {
-    toolName: string;
-    originalPayload: unknown;
-    deliveryAttempts: DeliveryAttempt[];
-    agentId?: string;
-    swarmId?: string;
-    tags?: string[];
-}
-export declare class DLQWriter {
-    private readonly filePath;
-    constructor(dataDir: string);
-    /** Enqueue a failed message into the DLQ */
-    enqueue(input: EnqueueInput): DLQEntry;
-    /** Get the file path (for reader/replayer) */
-    getFilePath(): string;
-}
-//# sourceMappingURL=dlq-writer.d.ts.map

package/packages/@monomind/cli/dist/src/dlq/dlq-writer.js

@@ -1,65 +0,0 @@
-/**
- * DLQ Writer (Task 37)
- *
- * JSONL append-only storage for dead-letter queue entries.
- */
-import { randomUUID } from 'crypto';
-import { existsSync, mkdirSync, appendFileSync } from 'fs';
-import { join, resolve, sep } from 'path';
-export class DLQWriter {
-    filePath;
-    constructor(dataDir) {
-        const resolvedDataDir = resolve(dataDir);
-        const allowedRoot = resolve(process.env.MONOMIND_DATA_DIR ?? process.cwd());
-        if (resolvedDataDir !== allowedRoot && !resolvedDataDir.startsWith(allowedRoot + sep)) {
-            throw new Error(`DLQ dataDir escapes allowed root: ${resolvedDataDir}`);
-        }
-        if (!existsSync(resolvedDataDir)) {
-            mkdirSync(resolvedDataDir, { recursive: true });
-        }
-        this.filePath = join(resolvedDataDir, 'dead-letter-queue.jsonl');
-    }
-    /** Enqueue a failed message into the DLQ */
-    enqueue(input) {
-        const lastAttempt = input.deliveryAttempts[input.deliveryAttempts.length - 1];
-        const firstAttempt = input.deliveryAttempts[0];
-        const entry = {
-            messageId: randomUUID(),
-            toolName: input.toolName,
-            originalPayload: input.originalPayload,
-            deliveryAttempts: input.deliveryAttempts,
-            finalError: lastAttempt?.errorMessage ?? 'unknown',
-            finalErrorType: lastAttempt?.errorType ?? 'unknown',
-            agentId: input.agentId,
-            swarmId: input.swarmId,
-            createdAt: firstAttempt?.attemptedAt ?? new Date().toISOString(),
-            archivedAt: new Date().toISOString(),
-            status: 'pending',
-            tags: input.tags ?? [],
-        };
-        // JSON.stringify can throw on circular references, BigInt, and non-serializable
-        // values. originalPayload is `unknown` (caller-controlled), so a malicious or
-        // malformed input could otherwise crash the writer mid-flight. Fall back to
-        // a sanitized record so the audit trail is preserved.
-        let serialized;
-        try {
-            serialized = JSON.stringify(entry);
-        }
-        catch {
-            serialized = JSON.stringify({
-                messageId: entry.messageId,
-                toolName: entry.toolName,
-                archivedAt: entry.archivedAt,
-                status: 'pending',
-                finalError: 'serialize_failed',
-            });
-        }
-        appendFileSync(this.filePath, serialized + '\n', 'utf-8');
-        return entry;
-    }
-    /** Get the file path (for reader/replayer) */
-    getFilePath() {
-        return this.filePath;
-    }
-}
-//# sourceMappingURL=dlq-writer.js.map

package/packages/@monomind/cli/dist/src/dlq/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * DLQ Module Barrel (Task 37)
- */
-export { DLQWriter } from './dlq-writer.js';
-export type { EnqueueInput } from './dlq-writer.js';
-export { DLQReader } from './dlq-reader.js';
-export type { DLQListOptions } from './dlq-reader.js';
-export { DLQReplayer } from './dlq-replayer.js';
-export type { ToolCaller } from './dlq-replayer.js';
-//# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/dlq/index.js

@@ -1,7 +0,0 @@
-/**
- * DLQ Module Barrel (Task 37)
- */
-export { DLQWriter } from './dlq-writer.js';
-export { DLQReader } from './dlq-reader.js';
-export { DLQReplayer } from './dlq-replayer.js';
-//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/eval/dataset-manager.d.ts

@@ -1,33 +0,0 @@
-import type { EvalDataset, EvalDatasetEntry, EvalTrace } from '../../../shared/src/types/eval.js';
-export interface CreateFromTracesOpts {
-    name: string;
-    description: string;
-    traces: EvalTrace[];
-    agentSlugs?: string[];
-}
-export declare class DatasetManager {
-    private datasetsPath;
-    private entriesPath;
-    constructor(datasetsPath: string, entriesPath: string);
-    /**
-     * Create a dataset from a set of filtered traces.
-     */
-    createFromTraces(opts: CreateFromTracesOpts): EvalDataset;
-    /**
-     * List all datasets.
-     */
-    listDatasets(): EvalDataset[];
-    /**
-     * Get entries for a specific dataset.
-     */
-    getEntries(datasetId: string): EvalDatasetEntry[];
-    /**
-     * Add a single trace to an existing dataset.
-     */
-    addTraceToDataset(datasetId: string, traceId: string): EvalDatasetEntry;
-    /**
-     * Export a dataset to a JSON file. Output path must be within `allowedRoot`.
-     */
-    exportToFile(datasetId: string, outputPath: string, allowedRoot?: string): void;
-}
-//# sourceMappingURL=dataset-manager.d.ts.map