monomind 1.10.0 → 1.10.2

package/packages/@monomind/cli/dist/src/agents/trigger-index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Trigger Index Persistence (Task 32)
+ *
+ * Handles saving and loading the TriggerIndex JSON file
+ * at `.monomind/trigger-index.json` (or a custom path).
+ */
+import type { TriggerIndex } from '../../../../@monoes/shared/src/types/trigger.js';
+/** Default path for the persisted trigger index. */
+export declare const DEFAULT_TRIGGER_INDEX_PATH = ".monomind/trigger-index.json";
+/**
+ * Save a TriggerIndex to a JSON file.
+ * Creates parent directories if they don't exist.
+ */
+export declare function save(index: TriggerIndex, path?: string): void;
+/**
+ * Load a TriggerIndex from a JSON file.
+ * Throws if the file does not exist or contains invalid JSON.
+ */
+export declare function load(path?: string): TriggerIndex;
+//# sourceMappingURL=trigger-index.d.ts.map

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

@@ -0,0 +1,38 @@
+/**
+ * Trigger Index Persistence (Task 32)
+ *
+ * Handles saving and loading the TriggerIndex JSON file
+ * at `.monomind/trigger-index.json` (or a custom path).
+ */
+import { readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+/** Default path for the persisted trigger index. */
+export const DEFAULT_TRIGGER_INDEX_PATH = '.monomind/trigger-index.json';
+/**
+ * Save a TriggerIndex to a JSON file.
+ * Creates parent directories if they don't exist.
+ */
+export function save(index, path = DEFAULT_TRIGGER_INDEX_PATH) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(index, null, 2), 'utf-8');
+}
+/**
+ * Load a TriggerIndex from a JSON file.
+ * Throws if the file does not exist or contains invalid JSON.
+ */
+export function load(path = DEFAULT_TRIGGER_INDEX_PATH) {
+    const raw = readFileSync(path, 'utf-8');
+    const parsed = JSON.parse(raw);
+    // Basic structural validation
+    if (!Array.isArray(parsed.patterns)) {
+        throw new Error(`Invalid trigger index: "patterns" must be an array`);
+    }
+    if (typeof parsed.builtAt !== 'string') {
+        throw new Error(`Invalid trigger index: "builtAt" must be a string`);
+    }
+    if (typeof parsed.totalAgentsScanned !== 'number') {
+        throw new Error(`Invalid trigger index: "totalAgentsScanned" must be a number`);
+    }
+    return parsed;
+}
+//# sourceMappingURL=trigger-index.js.map

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

@@ -0,0 +1,64 @@
+/**
+ * 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 type { TriggerPattern, TriggerMatch, TriggerIndex } from '../../../../@monomind/shared/src/types/trigger.js';
+export declare class TriggerScanner {
+    private compiled;
+    private patterns;
+    private totalAgentsScanned;
+    private buildingIndex;
+    constructor(patterns?: TriggerPattern[]);
+    /**
+     * 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: string): TriggerMatch[];
+    /**
+     * 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: string, allowedRoot?: string): TriggerIndex;
+    private _buildIndex;
+    /** Add a pattern to the index at runtime. */
+    addPattern(pattern: TriggerPattern): void;
+    /**
+     * Remove a specific pattern for an agent.
+     * Returns `true` if the pattern was found and removed.
+     */
+    removePattern(agentSlug: string, pattern: string): boolean;
+    /** Return a snapshot of the current index. */
+    getIndex(): TriggerIndex;
+    /** Number of compiled patterns. */
+    get size(): number;
+    private compileAndAdd;
+    private sortByPriority;
+    /** Recursively collect `.md` files (symlinks skipped, visited inodes tracked). */
+    private collectMdFiles;
+    /** Derive slug from filename. */
+    private slugFromPath;
+    /**
+     * 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
+     */
+    private extractTriggers;
+    private finalizeTrigger;
+    private extractYamlValue;
+}
+//# sourceMappingURL=trigger-scanner.d.ts.map

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

@@ -0,0 +1,308 @@
+/**
+ * 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

@@ -0,0 +1,18 @@
+/**
+ * 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

@@ -0,0 +1,64 @@
+/**
+ * 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

@@ -0,0 +1,60 @@
+/**
+ * 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