monomind 1.11.12 → 1.11.13

package/packages/@monomind/cli/dist/src/agents/trigger-scanner.js

@@ -1,308 +0,0 @@
-/**
- * Trigger Scanner (Task 32)
- *
- * Scans task descriptions against compiled trigger patterns
- * from agent frontmatter and returns matches.
- *
- * - Patterns are tested in descending priority order.
- * - A `takeover` match short-circuits: only that agent is returned.
- * - `inject` matches accumulate as additional candidates.
- * - Invalid regex patterns are silently skipped.
- */
-import { readFileSync, readdirSync, lstatSync, statSync, realpathSync } from 'fs';
-import { join, extname, resolve, sep } from 'path';
-export class TriggerScanner {
-    compiled = [];
-    patterns = [];
-    totalAgentsScanned = 0;
-    buildingIndex = false;
-    constructor(patterns = []) {
-        for (const p of patterns) {
-            this.compileAndAdd(p);
-        }
-        this.sortByPriority();
-    }
-    // ---------------------------------------------------------------------------
-    // Public API
-    // ---------------------------------------------------------------------------
-    /**
-     * Test all patterns against `taskDescription` and return matches.
-     *
-     * Patterns are tested in descending priority order.
-     * If a `takeover` pattern matches, scanning stops immediately
-     * and only that agent is returned.
-     */
-    scan(taskDescription) {
-        const matches = [];
-        for (const { source, regex } of this.compiled) {
-            // Reset lastIndex in case the regex has the global flag
-            regex.lastIndex = 0;
-            const m = regex.exec(taskDescription);
-            if (!m)
-                continue;
-            const match = {
-                agentSlug: source.agentSlug,
-                pattern: source.pattern,
-                mode: source.mode,
-                matchedText: m[0],
-            };
-            if (source.mode === 'takeover') {
-                // Short-circuit: return only this agent
-                return [match];
-            }
-            matches.push(match);
-        }
-        return matches;
-    }
-    /**
-     * Build an index by scanning agent markdown files under `agentDir`.
-     *
-     * Reads each `.md` file, extracts YAML frontmatter, and looks for
-     * `triggers:` entries with `pattern`, `mode`, and optional `priority`.
-     */
-    buildIndex(agentDir, allowedRoot) {
-        if (this.buildingIndex) {
-            throw new Error('buildIndex is already running; concurrent invocations are not safe');
-        }
-        this.buildingIndex = true;
-        try {
-            return this._buildIndex(agentDir, allowedRoot);
-        }
-        finally {
-            this.buildingIndex = false;
-        }
-    }
-    _buildIndex(agentDir, allowedRoot) {
-        if (allowedRoot) {
-            let resolvedDir;
-            let resolvedRoot;
-            try {
-                resolvedDir = realpathSync(resolve(agentDir));
-            }
-            catch {
-                resolvedDir = resolve(agentDir);
-            }
-            try {
-                resolvedRoot = realpathSync(resolve(allowedRoot));
-            }
-            catch {
-                resolvedRoot = resolve(allowedRoot);
-            }
-            if (!resolvedDir.startsWith(resolvedRoot + sep) && resolvedDir !== resolvedRoot) {
-                throw new Error(`Agent directory escapes workspace: ${resolvedDir}`);
-            }
-        }
-        const mdFiles = this.collectMdFiles(agentDir);
-        this.patterns = [];
-        this.compiled = [];
-        this.totalAgentsScanned = mdFiles.length;
-        const MAX_AGENT_FILE_BYTES = 1 * 1024 * 1024;
-        for (const filePath of mdFiles) {
-            let content;
-            try {
-                if (statSync(filePath).size > MAX_AGENT_FILE_BYTES)
-                    continue;
-                content = readFileSync(filePath, 'utf-8');
-            }
-            catch {
-                continue;
-            }
-            const slug = this.slugFromPath(filePath);
-            const triggers = this.extractTriggers(content, slug);
-            for (const t of triggers) {
-                this.compileAndAdd(t);
-            }
-        }
-        this.sortByPriority();
-        return {
-            patterns: [...this.patterns],
-            builtAt: new Date().toISOString(),
-            totalAgentsScanned: this.totalAgentsScanned,
-        };
-    }
-    /** Add a pattern to the index at runtime. */
-    addPattern(pattern) {
-        this.compileAndAdd(pattern);
-        this.sortByPriority();
-    }
-    /**
-     * Remove a specific pattern for an agent.
-     * Returns `true` if the pattern was found and removed.
-     */
-    removePattern(agentSlug, pattern) {
-        const idx = this.patterns.findIndex((p) => p.agentSlug === agentSlug && p.pattern === pattern);
-        if (idx === -1)
-            return false;
-        this.patterns.splice(idx, 1);
-        this.compiled.splice(idx, 1);
-        return true;
-    }
-    /** Return a snapshot of the current index. */
-    getIndex() {
-        return {
-            patterns: [...this.patterns],
-            builtAt: new Date().toISOString(),
-            totalAgentsScanned: this.totalAgentsScanned,
-        };
-    }
-    /** Number of compiled patterns. */
-    get size() {
-        return this.compiled.length;
-    }
-    // ---------------------------------------------------------------------------
-    // Internal helpers
-    // ---------------------------------------------------------------------------
-    compileAndAdd(pattern) {
-        if (pattern.pattern.length > 200)
-            return;
-        // Reject patterns with nested/repeated quantifiers (ReDoS vectors)
-        // Covers: (a+)+, (a|b+)+, (a?){n}, ((a)+)+, [a-z]+{n}
-        if (/(\(.*[+*?].*\)|[+*?]){2,}|\{[0-9,]+\}.*[+*?]|(\[[^\]]*\]|\.)[+*?][+*?]/.test(pattern.pattern))
-            return;
-        if (/\([^)]*([+*][^)]*){2,}\)/.test(pattern.pattern))
-            return;
-        try {
-            const regex = new RegExp(pattern.pattern, 'i');
-            this.patterns.push(pattern);
-            this.compiled.push({ source: pattern, regex });
-        }
-        catch {
-            // Invalid regex — skip silently
-        }
-    }
-    sortByPriority() {
-        // Sort both arrays in-sync by descending priority
-        const indexed = this.patterns.map((p, i) => ({ p, c: this.compiled[i], priority: p.priority }));
-        indexed.sort((a, b) => b.priority - a.priority);
-        this.patterns = indexed.map((x) => x.p);
-        this.compiled = indexed.map((x) => x.c);
-    }
-    /** Recursively collect `.md` files (symlinks skipped, visited inodes tracked). */
-    collectMdFiles(dir, visited = new Set()) {
-        const results = [];
-        let entries;
-        try {
-            entries = readdirSync(dir);
-        }
-        catch {
-            return results;
-        }
-        for (const entry of entries) {
-            const full = join(dir, entry);
-            let lstat;
-            try {
-                lstat = lstatSync(full);
-            }
-            catch {
-                continue;
-            }
-            if (lstat.isSymbolicLink())
-                continue;
-            if (lstat.isDirectory()) {
-                if (visited.has(lstat.ino))
-                    continue;
-                visited.add(lstat.ino);
-                results.push(...this.collectMdFiles(full, visited));
-            }
-            else if (lstat.isFile() && extname(entry) === '.md') {
-                results.push(full);
-            }
-        }
-        return results;
-    }
-    /** Derive slug from filename. */
-    slugFromPath(filePath) {
-        const base = filePath.split('/').pop() ?? '';
-        return base
-            .replace(/\.md$/i, '')
-            .toLowerCase()
-            .replace(/\s+/g, '-')
-            .replace(/[^a-z0-9-]/g, '');
-    }
-    /**
-     * Extract trigger definitions from markdown frontmatter.
-     *
-     * Looks for a YAML block between `---` markers, then finds lines like:
-     *   - pattern: "\\b(auth|jwt)\\b"
-     *     mode: "inject"
-     *     priority: 10
-     */
-    extractTriggers(content, agentSlug) {
-        const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-        if (!fmMatch)
-            return [];
-        const block = fmMatch[1];
-        const triggers = [];
-        // Find trigger blocks: lines starting with "- pattern:" under a triggers: section
-        const lines = block.split('\n');
-        let inTriggers = false;
-        let currentTrigger = null;
-        for (const line of lines) {
-            const trimmed = line.trim();
-            // Measure leading whitespace to distinguish top-level keys from nested props
-            const indent = line.length - line.trimStart().length;
-            if (trimmed === 'triggers:' || trimmed.startsWith('triggers:')) {
-                inTriggers = true;
-                continue;
-            }
-            // Exit triggers section when we hit a non-indented top-level key (indent 0)
-            if (inTriggers && indent === 0 && /^[a-zA-Z]/.test(trimmed)) {
-                inTriggers = false;
-                if (currentTrigger?.pattern) {
-                    triggers.push(this.finalizeTrigger(currentTrigger, agentSlug));
-                }
-                currentTrigger = null;
-                continue;
-            }
-            if (!inTriggers)
-                continue;
-            // New list item
-            if (trimmed.startsWith('- pattern:')) {
-                if (currentTrigger?.pattern) {
-                    triggers.push(this.finalizeTrigger(currentTrigger, agentSlug));
-                }
-                currentTrigger = {
-                    pattern: this.extractYamlValue(trimmed.replace(/^- pattern:\s*/, '')),
-                    agentSlug,
-                };
-            }
-            else if (currentTrigger && trimmed.startsWith('mode:')) {
-                const val = this.extractYamlValue(trimmed.replace(/^mode:\s*/, ''));
-                if (val === 'inject' || val === 'takeover') {
-                    currentTrigger.mode = val;
-                }
-            }
-            else if (currentTrigger && trimmed.startsWith('priority:')) {
-                const val = parseInt(trimmed.replace(/^priority:\s*/, ''), 10);
-                if (!isNaN(val)) {
-                    currentTrigger.priority = val;
-                }
-            }
-        }
-        // Flush last trigger
-        if (currentTrigger?.pattern) {
-            triggers.push(this.finalizeTrigger(currentTrigger, agentSlug));
-        }
-        return triggers;
-    }
-    finalizeTrigger(partial, agentSlug) {
-        return {
-            pattern: partial.pattern,
-            mode: partial.mode ?? 'inject',
-            priority: partial.priority ?? 0,
-            agentSlug,
-        };
-    }
-    extractYamlValue(raw) {
-        let v = raw.trim();
-        if (v.startsWith('"') && v.endsWith('"')) {
-            // YAML double-quoted: unescape \\ → \ so "\\b" becomes \b (word boundary)
-            v = v.slice(1, -1).replace(/\\\\/g, '\\');
-        }
-        else if (v.startsWith("'") && v.endsWith("'")) {
-            v = v.slice(1, -1);
-        }
-        return v;
-    }
-}
-//# sourceMappingURL=trigger-scanner.js.map

package/packages/@monomind/cli/dist/src/agents/version-diff.d.ts

@@ -1,18 +0,0 @@
-/**
- * Agent Version Diff Utility (Task 29)
- *
- * Computes a simple unified-style diff between two content strings.
- */
-export interface LineDiffResult {
-    additions: number;
-    deletions: number;
-    hunks: string;
-}
-/**
- * Compute a unified diff between two content strings.
- *
- * Uses a simple line-by-line LCS-based approach to produce
- * addition/deletion counts and a unified-style hunk string.
- */
-export declare function computeUnifiedDiff(oldContent: string, newContent: string): LineDiffResult;
-//# sourceMappingURL=version-diff.d.ts.map

package/packages/@monomind/cli/dist/src/agents/version-diff.js

@@ -1,64 +0,0 @@
-/**
- * Agent Version Diff Utility (Task 29)
- *
- * Computes a simple unified-style diff between two content strings.
- */
-/**
- * Compute a unified diff between two content strings.
- *
- * Uses a simple line-by-line LCS-based approach to produce
- * addition/deletion counts and a unified-style hunk string.
- */
-export function computeUnifiedDiff(oldContent, newContent) {
-    const oldLines = oldContent.split('\n');
-    const newLines = newContent.split('\n');
-    // Simple LCS to find common subsequence
-    const m = oldLines.length;
-    const n = newLines.length;
-    // Build LCS table
-    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
-    for (let i = 1; i <= m; i++) {
-        for (let j = 1; j <= n; j++) {
-            if (oldLines[i - 1] === newLines[j - 1]) {
-                dp[i][j] = dp[i - 1][j - 1] + 1;
-            }
-            else {
-                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
-            }
-        }
-    }
-    // Backtrack to produce diff lines
-    const diffLines = [];
-    let additions = 0;
-    let deletions = 0;
-    let i = m;
-    let j = n;
-    const result = [];
-    while (i > 0 || j > 0) {
-        if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
-            result.push({ type: ' ', line: oldLines[i - 1] });
-            i--;
-            j--;
-        }
-        else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
-            result.push({ type: '+', line: newLines[j - 1] });
-            additions++;
-            j--;
-        }
-        else {
-            result.push({ type: '-', line: oldLines[i - 1] });
-            deletions++;
-            i--;
-        }
-    }
-    result.reverse();
-    for (const entry of result) {
-        diffLines.push(`${entry.type} ${entry.line}`);
-    }
-    return {
-        additions,
-        deletions,
-        hunks: diffLines.join('\n'),
-    };
-}
-//# sourceMappingURL=version-diff.js.map

package/packages/@monomind/cli/dist/src/agents/version-store.d.ts

@@ -1,60 +0,0 @@
-/**
- * Agent Version Store (Task 29)
- *
- * JSONL-based append-only storage for agent definition versions.
- * Supports save, list, get, rollback, and diff operations.
- */
-import type { AgentVersionRecord, DiffResult } from '../../../shared/src/types/agent-version.js';
-/**
- * JSONL-based agent version store.
- *
- * Each slug's versions are stored in `<dirPath>/versions.jsonl`, one JSON
- * object per line.  Rollback rewrites the file to update `isCurrent` flags.
- */
-export declare class AgentVersionStore {
-    private readonly dirPath;
-    private readonly filePath;
-    constructor(dirPath: string);
-    private readAll;
-    private writeAll;
-    /**
-     * Save a new version for the given agent slug.
-     *
-     * Computes a SHA-256 hash of the content, marks all previous versions for
-     * the same slug as non-current, and appends the new record.
-     */
-    saveVersion(slug: string, content: string, version: string, changelog: string, opts?: {
-        deprecated?: boolean;
-        deprecatedBy?: string;
-        capturedBy?: string;
-    }): AgentVersionRecord;
-    /**
-     * List all versions for a slug, sorted by capturedAt DESC (newest first).
-     * Uses insertion order (line index) as a stable tiebreaker.
-     */
-    listVersions(slug: string): AgentVersionRecord[];
-    /**
-     * Get the current active version for a slug, or null.
-     */
-    getCurrent(slug: string): AgentVersionRecord | null;
-    /**
-     * Get a specific version by slug and semver string, or null.
-     */
-    getVersion(slug: string, version: string): AgentVersionRecord | null;
-    /**
-     * Roll back to a specific version.
-     *
-     * Marks the target version as current and all others for that slug as
-     * non-current.  Rewrites the JSONL file.
-     *
-     * @throws Error if the target version does not exist.
-     */
-    rollback(slug: string, toVersion: string): AgentVersionRecord;
-    /**
-     * Compute a line-level diff between two versions of the same agent.
-     *
-     * @throws Error if either version does not exist.
-     */
-    diff(slug: string, fromVersion: string, toVersion: string): DiffResult;
-}
-//# sourceMappingURL=version-store.d.ts.map

package/packages/@monomind/cli/dist/src/agents/version-store.js

@@ -1,235 +0,0 @@
-/**
- * Agent Version Store (Task 29)
- *
- * JSONL-based append-only storage for agent definition versions.
- * Supports save, list, get, rollback, and diff operations.
- */
-import { createHash, randomUUID, randomBytes } from 'crypto';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, statSync } from 'fs';
-import { join } from 'path';
-import { computeUnifiedDiff } from './version-diff.js';
-import { parseJsonl } from '../utils/parse-jsonl.js';
-function toStored(r) {
-    return {
-        id: r.id,
-        slug: r.slug,
-        version: r.version,
-        changelog: r.changelog,
-        deprecated: r.deprecated,
-        deprecatedBy: r.deprecatedBy,
-        content: r.content,
-        contentHash: r.contentHash,
-        capturedAt: r.capturedAt instanceof Date
-            ? r.capturedAt.toISOString()
-            : String(r.capturedAt),
-        capturedBy: r.capturedBy,
-        isCurrent: r.isCurrent,
-    };
-}
-function fromStored(s) {
-    return {
-        id: s.id,
-        slug: s.slug,
-        version: s.version,
-        changelog: s.changelog,
-        deprecated: s.deprecated,
-        deprecatedBy: s.deprecatedBy,
-        content: s.content,
-        contentHash: s.contentHash,
-        capturedAt: new Date(s.capturedAt),
-        capturedBy: s.capturedBy,
-        isCurrent: s.isCurrent,
-    };
-}
-/**
- * JSONL-based agent version store.
- *
- * Each slug's versions are stored in `<dirPath>/versions.jsonl`, one JSON
- * object per line.  Rollback rewrites the file to update `isCurrent` flags.
- */
-export class AgentVersionStore {
-    dirPath;
-    filePath;
-    constructor(dirPath) {
-        this.dirPath = dirPath;
-        if (!existsSync(dirPath)) {
-            mkdirSync(dirPath, { recursive: true });
-        }
-        this.filePath = join(dirPath, 'versions.jsonl');
-    }
-    // ---------------------------------------------------------------------------
-    // Persistence helpers
-    // ---------------------------------------------------------------------------
-    readAll() {
-        if (!existsSync(this.filePath)) {
-            return [];
-        }
-        const stat = statSync(this.filePath);
-        if (stat.size > 10 * 1024 * 1024) {
-            throw new Error('Version store exceeds size limit; run compaction');
-        }
-        const raw = readFileSync(this.filePath, 'utf-8');
-        // Drop any record whose stored contentHash does not match the SHA-256 of
-        // its content. saveVersion advertises tamper-evidence by computing the
-        // hash; without this verification step, an attacker who can write the
-        // JSONL file can swap `content` with a poisoned agent prompt while
-        // leaving `contentHash` unchanged, and the next getCurrent() returns
-        // the tampered prompt verbatim into the LLM context.
-        const records = parseJsonl(raw);
-        const verified = [];
-        for (const r of records) {
-            if (typeof r?.content !== 'string' ||
-                typeof r?.contentHash !== 'string' ||
-                typeof r?.id !== 'string' ||
-                typeof r?.slug !== 'string' ||
-                typeof r?.version !== 'string' ||
-                typeof r?.changelog !== 'string' ||
-                typeof r?.capturedBy !== 'string' ||
-                typeof r?.capturedAt !== 'string')
-                continue;
-            const actual = createHash('sha256').update(r.content).digest('hex');
-            if (actual !== r.contentHash)
-                continue; // silently drop tampered record
-            verified.push(r);
-        }
-        return verified.map(fromStored);
-    }
-    writeAll(records) {
-        const lines = records.map((r) => JSON.stringify(toStored(r)));
-        const tmp = `${this.filePath}.${process.pid}.${randomBytes(8).toString('hex')}.tmp`;
-        writeFileSync(tmp, lines.join('\n') + '\n', 'utf-8');
-        renameSync(tmp, this.filePath);
-    }
-    // ---------------------------------------------------------------------------
-    // Public API
-    // ---------------------------------------------------------------------------
-    /**
-     * Save a new version for the given agent slug.
-     *
-     * Computes a SHA-256 hash of the content, marks all previous versions for
-     * the same slug as non-current, and appends the new record.
-     */
-    saveVersion(slug, content, version, changelog, opts = {}) {
-        const MAX_CONTENT_BYTES = 512 * 1024;
-        if (Buffer.byteLength(content, 'utf-8') > MAX_CONTENT_BYTES) {
-            throw new Error(`content exceeds maximum allowed size (${MAX_CONTENT_BYTES} bytes)`);
-        }
-        const contentHash = createHash('sha256').update(content).digest('hex');
-        // SINGLE-WRITER CONTRACT: version-store is written only by the daemon process.
-        // Concurrent saveVersion() calls from multiple processes would race on readAll/writeAll.
-        // If multi-writer access is needed in future, introduce an advisory lock here.
-        const existing = this.readAll();
-        for (const rec of existing) {
-            if (rec.slug === slug && rec.isCurrent) {
-                rec.isCurrent = false;
-            }
-        }
-        const record = {
-            id: randomUUID(),
-            slug,
-            version,
-            changelog,
-            deprecated: opts.deprecated ?? false,
-            deprecatedBy: opts.deprecatedBy,
-            content,
-            contentHash,
-            capturedAt: new Date(),
-            capturedBy: opts.capturedBy ?? 'system',
-            isCurrent: true,
-        };
-        existing.push(record);
-        this.writeAll(existing);
-        return record;
-    }
-    /**
-     * List all versions for a slug, sorted by capturedAt DESC (newest first).
-     * Uses insertion order (line index) as a stable tiebreaker.
-     */
-    listVersions(slug) {
-        const all = this.readAll();
-        const indexed = all.map((r, i) => ({ r, i }));
-        return indexed
-            .filter(({ r }) => r.slug === slug)
-            .sort((a, b) => {
-            const timeDiff = new Date(b.r.capturedAt).getTime() -
-                new Date(a.r.capturedAt).getTime();
-            return timeDiff !== 0 ? timeDiff : b.i - a.i;
-        })
-            .map(({ r }) => r);
-    }
-    /**
-     * Get the current active version for a slug, or null.
-     */
-    getCurrent(slug) {
-        const all = this.readAll();
-        const indexed = all.map((r, i) => ({ r, i }));
-        const matching = indexed.filter(({ r }) => r.slug === slug && r.isCurrent);
-        if (matching.length === 0)
-            return null;
-        // Return the most recent current record (insertion order as tiebreaker)
-        return matching.sort((a, b) => {
-            const timeDiff = new Date(b.r.capturedAt).getTime() -
-                new Date(a.r.capturedAt).getTime();
-            return timeDiff !== 0 ? timeDiff : b.i - a.i;
-        })[0].r;
-    }
-    /**
-     * Get a specific version by slug and semver string, or null.
-     */
-    getVersion(slug, version) {
-        return (this.readAll().find((r) => r.slug === slug && r.version === version) ?? null);
-    }
-    /**
-     * Roll back to a specific version.
-     *
-     * Marks the target version as current and all others for that slug as
-     * non-current.  Rewrites the JSONL file.
-     *
-     * @throws Error if the target version does not exist.
-     */
-    rollback(slug, toVersion) {
-        const all = this.readAll();
-        let target;
-        for (const rec of all) {
-            if (rec.slug === slug) {
-                if (rec.version === toVersion) {
-                    rec.isCurrent = true;
-                    target = rec;
-                }
-                else {
-                    rec.isCurrent = false;
-                }
-            }
-        }
-        if (!target) {
-            throw new Error(`Version "${toVersion}" not found for agent "${slug}"`);
-        }
-        this.writeAll(all);
-        return target;
-    }
-    /**
-     * Compute a line-level diff between two versions of the same agent.
-     *
-     * @throws Error if either version does not exist.
-     */
-    diff(slug, fromVersion, toVersion) {
-        const from = this.getVersion(slug, fromVersion);
-        if (!from) {
-            throw new Error(`Version "${fromVersion}" not found for agent "${slug}"`);
-        }
-        const to = this.getVersion(slug, toVersion);
-        if (!to) {
-            throw new Error(`Version "${toVersion}" not found for agent "${slug}"`);
-        }
-        const { additions, deletions, hunks } = computeUnifiedDiff(from.content, to.content);
-        return {
-            slug,
-            fromVersion,
-            toVersion,
-            additions,
-            deletions,
-            hunks,
-        };
-    }
-}
-//# sourceMappingURL=version-store.js.map