@4onstudios/iris-agent 0.1.0

package/dist/api/core/library/mcpServerProvider.js

@@ -0,0 +1,152 @@
+/**
+ * MCP Server Definition Provider
+ * Provides MCP servers from application settings
+ */
+import { EventEmitter } from "events";
+/**
+ * Default MCP Server Provider
+ * Provides servers from application settings/configuration
+ */
+export class DefaultMcpServerProvider extends EventEmitter {
+    servers = [];
+    changeListeners = new Set();
+    constructor(servers = []) {
+        super();
+        this.servers = servers;
+    }
+    /**
+     * Update the list of available servers
+     */
+    updateServers(servers) {
+        this.servers = servers;
+        this.notifyChange();
+    }
+    /**
+     * Provide available MCP servers
+     */
+    async provideMcpServerDefinitions(signal) {
+        if (signal?.aborted) {
+            throw new Error("Operation cancelled");
+        }
+        // Return enabled servers
+        return this.servers.filter(server => server.enabled);
+    }
+    /**
+     * Optional: resolve server before starting
+     * Can be used for authentication, validation, etc.
+     */
+    async resolveMcpServerDefinition(server, signal) {
+        if (signal?.aborted) {
+            throw new Error("Operation cancelled");
+        }
+        // For now, just return the server as-is
+        // In the future, this could:
+        // - Validate the server configuration
+        // - Prompt for authentication if needed
+        // - Expand environment variables
+        // - Check if the command exists
+        return server;
+    }
+    /**
+     * Listen for server changes
+     */
+    onDidChangeMcpServerDefinitions(listener) {
+        this.changeListeners.add(listener);
+        return () => {
+            this.changeListeners.delete(listener);
+        };
+    }
+    /**
+     * Notify listeners of changes
+     */
+    notifyChange() {
+        for (const listener of this.changeListeners) {
+            try {
+                listener();
+            }
+            catch (error) {
+                console.error("Error in MCP server change listener:", error);
+            }
+        }
+    }
+}
+/**
+ * Dynamic MCP Server Provider
+ * Can discover servers from various sources
+ */
+export class DynamicMcpServerProvider extends EventEmitter {
+    discoveryFunctions = [];
+    changeListeners = new Set();
+    /**
+     * Register a discovery function
+     */
+    registerDiscovery(fn) {
+        this.discoveryFunctions.push(fn);
+        this.notifyChange();
+        return () => {
+            const index = this.discoveryFunctions.indexOf(fn);
+            if (index >= 0) {
+                this.discoveryFunctions.splice(index, 1);
+                this.notifyChange();
+            }
+        };
+    }
+    /**
+     * Provide available MCP servers by running all discovery functions
+     */
+    async provideMcpServerDefinitions(signal) {
+        const allServers = [];
+        for (const discover of this.discoveryFunctions) {
+            try {
+                const servers = await discover(signal);
+                allServers.push(...servers);
+            }
+            catch (error) {
+                console.error("Error discovering MCP servers:", error);
+            }
+        }
+        // Deduplicate by server ID
+        const seen = new Set();
+        return allServers.filter(server => {
+            if (seen.has(server.id)) {
+                return false;
+            }
+            seen.add(server.id);
+            return true;
+        });
+    }
+    /**
+     * Listen for server changes
+     */
+    onDidChangeMcpServerDefinitions(listener) {
+        this.changeListeners.add(listener);
+        return () => {
+            this.changeListeners.delete(listener);
+        };
+    }
+    /**
+     * Notify listeners of changes
+     */
+    notifyChange() {
+        for (const listener of this.changeListeners) {
+            try {
+                listener();
+            }
+            catch (error) {
+                console.error("Error in MCP server change listener:", error);
+            }
+        }
+    }
+}
+/**
+ * Create a default provider from static configuration
+ */
+export function createDefaultProvider(servers) {
+    return new DefaultMcpServerProvider(servers);
+}
+/**
+ * Create a dynamic provider for runtime discovery
+ */
+export function createDynamicProvider() {
+    return new DynamicMcpServerProvider();
+}

package/dist/api/core/library/mcpSettings.d.ts

@@ -0,0 +1,20 @@
+export declare const MCP_SERVERS_STORAGE_KEY = "settings.mcpServers";
+export declare const MAX_MCP_SERVERS = 10;
+export type McpServerConfig = {
+    id: string;
+    name: string;
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+    enabled: boolean;
+};
+export declare const normalizeMcpServerCommandLine: (command: string, args: string[]) => {
+    command: string;
+    args: string[];
+};
+export declare const sanitizeMcpServer: (input: unknown, index?: number) => McpServerConfig | null;
+export declare const sanitizeMcpServers: (input: unknown, maxServers?: number) => McpServerConfig[];
+export declare const toStableMcpFingerprint: (servers: McpServerConfig[]) => string;
+export declare const loadMcpServersFromStorage: () => McpServerConfig[];
+export declare const saveMcpServersToStorage: (servers: McpServerConfig[]) => void;
+export declare const getEnabledMcpServersFromStorage: () => McpServerConfig[];

package/dist/api/core/library/mcpSettings.js

@@ -0,0 +1,131 @@
+export const MCP_SERVERS_STORAGE_KEY = "settings.mcpServers";
+export const MAX_MCP_SERVERS = 10;
+const MAX_COMMAND_LENGTH = 300;
+const MAX_NAME_LENGTH = 100;
+const MAX_ARG_LENGTH = 500;
+const MAX_ARGS = 40;
+const MAX_ENV_VARS = 60;
+const MAX_ENV_KEY_LENGTH = 120;
+const MAX_ENV_VALUE_LENGTH = 2000;
+const isSafeEnvKey = (key) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(key);
+const splitCommandString = (value) => {
+    const parts = [];
+    const regex = /[^\s"']+|"([^"]*)"|'([^']*)'/g;
+    let match;
+    while ((match = regex.exec(value)) !== null) {
+        parts.push(match[1] ?? match[2] ?? match[0]);
+    }
+    return parts;
+};
+export const normalizeMcpServerCommandLine = (command, args) => {
+    const normalizedCommand = command.trim();
+    const tokens = splitCommandString(normalizedCommand);
+    if (tokens.length === 0) {
+        return { command: normalizedCommand, args: [...args] };
+    }
+    return {
+        command: tokens[0],
+        args: [...tokens.slice(1), ...args],
+    };
+};
+const safeString = (value, maxLength) => typeof value === "string" ? value.trim().slice(0, maxLength) : "";
+const sanitizeArgs = (args) => {
+    if (!Array.isArray(args))
+        return [];
+    return args
+        .map((entry) => safeString(entry, MAX_ARG_LENGTH))
+        .filter(Boolean)
+        .slice(0, MAX_ARGS);
+};
+const sanitizeEnv = (env) => {
+    if (!env || typeof env !== "object" || Array.isArray(env))
+        return {};
+    const entries = Object.entries(env)
+        .map(([key, value]) => [safeString(key, MAX_ENV_KEY_LENGTH), safeString(value, MAX_ENV_VALUE_LENGTH)])
+        .filter(([key]) => key.length > 0 && isSafeEnvKey(key))
+        .slice(0, MAX_ENV_VARS);
+    return Object.fromEntries(entries);
+};
+const getDefaultId = (index) => `mcp-${Date.now()}-${index}`;
+const normalizeMcpServerDraft = (input, index = 0) => {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return null;
+    const raw = input;
+    const id = safeString(raw.id, 120) || getDefaultId(index);
+    const command = safeString(raw.command, MAX_COMMAND_LENGTH);
+    const name = safeString(raw.name, MAX_NAME_LENGTH) || command || "New MCP Server";
+    return {
+        id,
+        name,
+        command,
+        args: sanitizeArgs(raw.args),
+        env: sanitizeEnv(raw.env),
+        enabled: raw.enabled !== false,
+    };
+};
+const normalizeMcpServerDrafts = (input, maxServers = MAX_MCP_SERVERS) => {
+    if (!Array.isArray(input))
+        return [];
+    return input
+        .map((entry, index) => normalizeMcpServerDraft(entry, index))
+        .filter((entry) => entry !== null)
+        .slice(0, maxServers);
+};
+export const sanitizeMcpServer = (input, index = 0) => {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return null;
+    const raw = input;
+    const command = safeString(raw.command, MAX_COMMAND_LENGTH);
+    if (!command)
+        return null;
+    const id = safeString(raw.id, 120) || getDefaultId(index);
+    const name = safeString(raw.name, MAX_NAME_LENGTH) || command;
+    return {
+        id,
+        name,
+        command,
+        args: sanitizeArgs(raw.args),
+        env: sanitizeEnv(raw.env),
+        enabled: raw.enabled !== false,
+    };
+};
+export const sanitizeMcpServers = (input, maxServers = MAX_MCP_SERVERS) => {
+    if (!Array.isArray(input))
+        return [];
+    return input
+        .map((entry, index) => sanitizeMcpServer(entry, index))
+        .filter((entry) => entry !== null)
+        .slice(0, maxServers);
+};
+export const toStableMcpFingerprint = (servers) => {
+    const normalized = servers
+        .map((server) => ({
+        id: server.id,
+        name: server.name,
+        command: server.command,
+        args: [...server.args],
+        env: Object.fromEntries(Object.entries(server.env).sort(([a], [b]) => a.localeCompare(b))),
+        enabled: server.enabled,
+    }))
+        .sort((a, b) => a.id.localeCompare(b.id));
+    return JSON.stringify(normalized);
+};
+export const loadMcpServersFromStorage = () => {
+    if (typeof window === "undefined")
+        return [];
+    try {
+        const raw = localStorage.getItem(MCP_SERVERS_STORAGE_KEY);
+        if (!raw)
+            return [];
+        return normalizeMcpServerDrafts(JSON.parse(raw));
+    }
+    catch {
+        return [];
+    }
+};
+export const saveMcpServersToStorage = (servers) => {
+    if (typeof window === "undefined")
+        return;
+    localStorage.setItem(MCP_SERVERS_STORAGE_KEY, JSON.stringify(normalizeMcpServerDrafts(servers)));
+};
+export const getEnabledMcpServersFromStorage = () => sanitizeMcpServers(loadMcpServersFromStorage().filter((server) => server.enabled));

package/dist/api/core/library/patternMatcher.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Pattern Matcher - Advanced code pattern detection and matching
+ * Inspired by spaCy's pattern matching for code analysis
+ */
+type PatternRuleValue = CodeToken[keyof CodeToken] | CodeToken[keyof CodeToken][];
+type PatternRule = Partial<Record<keyof CodeToken | "OP", PatternRuleValue>>;
+type CodeToken = {
+    text: string;
+    type: string;
+    pos: string;
+    line: number;
+    index: number;
+};
+type PatternMatch = {
+    pattern: string;
+    tokens: CodeToken[];
+    start: number;
+    end: number;
+};
+export declare class Pattern {
+    name: string;
+    rules: PatternRule[];
+    constructor(name: string, rules: PatternRule[]);
+    match(tokens: CodeToken[]): PatternMatch[] | null;
+    tokenMatchesRule(token: CodeToken, rule: PatternRule): boolean;
+}
+export declare class CodeMatcher {
+    patterns: Map<string, Pattern>;
+    tokenCache: Map<string, CodeToken[]>;
+    constructor();
+    /**
+     * Add a pattern to match
+     */
+    addPattern(name: string, rules: PatternRule[]): void;
+    /**
+     * Remove a pattern
+     */
+    removePattern(name: string): void;
+    /**
+     * Match patterns in code
+     */
+    match(code: string, patternNames?: string[] | null): PatternMatch[];
+    /**
+     * Tokenize code into analyzable tokens
+     */
+    tokenize(code: string): CodeToken[];
+    /**
+     * Tokenize a single line
+     */
+    tokenizeLine(line: string, lineNum: number): CodeToken[];
+    /**
+     * Get token type
+     */
+    getTokenType(token: string): "KEYWORD" | "CLASS_NAME" | "NUMBER" | "IDENTIFIER" | "BRACKET" | "PUNCTUATION" | "OPERATOR" | "UNKNOWN";
+    /**
+     * Get part of speech (simplified for code)
+     */
+    getPartOfSpeech(token: string, type: string): string;
+    /**
+     * Clear token cache
+     */
+    clearCache(): void;
+}
+export declare const CommonPatterns: Record<string, PatternRule[]>;
+export declare function createDefaultMatcher(): CodeMatcher;
+export default CodeMatcher;

package/dist/api/core/library/patternMatcher.js

@@ -0,0 +1,284 @@
+/**
+ * Pattern Matcher - Advanced code pattern detection and matching
+ * Inspired by spaCy's pattern matching for code analysis
+ */
+export class Pattern {
+    name;
+    rules;
+    constructor(name, rules) {
+        this.name = name;
+        this.rules = rules; // Array of matching rules
+    }
+    match(tokens) {
+        // Check if tokens match this pattern
+        if (tokens.length < this.rules.length)
+            return null;
+        const matches = [];
+        for (let i = 0; i <= tokens.length - this.rules.length; i++) {
+            let isMatch = true;
+            const matchedTokens = [];
+            for (let j = 0; j < this.rules.length; j++) {
+                const token = tokens[i + j];
+                const rule = this.rules[j];
+                if (!this.tokenMatchesRule(token, rule)) {
+                    isMatch = false;
+                    break;
+                }
+                matchedTokens.push(token);
+            }
+            if (isMatch) {
+                matches.push({
+                    pattern: this.name,
+                    tokens: matchedTokens,
+                    start: i,
+                    end: i + this.rules.length,
+                });
+            }
+        }
+        return matches.length > 0 ? matches : null;
+    }
+    tokenMatchesRule(token, rule) {
+        // Check if token matches the rule criteria
+        for (const [key, value] of Object.entries(rule)) {
+            if (key === "OP")
+                continue; // Optional operator, handle separately
+            const tokenValue = token[key];
+            if (Array.isArray(value)) {
+                if (!value.includes(tokenValue))
+                    return false;
+            }
+            else {
+                if (tokenValue !== value)
+                    return false;
+            }
+        }
+        return true;
+    }
+}
+export class CodeMatcher {
+    patterns;
+    tokenCache;
+    constructor() {
+        this.patterns = new Map();
+        this.tokenCache = new Map();
+    }
+    /**
+     * Add a pattern to match
+     */
+    addPattern(name, rules) {
+        const pattern = new Pattern(name, rules);
+        this.patterns.set(name, pattern);
+    }
+    /**
+     * Remove a pattern
+     */
+    removePattern(name) {
+        this.patterns.delete(name);
+    }
+    /**
+     * Match patterns in code
+     */
+    match(code, patternNames = null) {
+        const tokens = this.tokenize(code);
+        const allMatches = [];
+        const patternsToMatch = patternNames
+            ? patternNames.flatMap((name) => {
+                const pattern = this.patterns.get(name);
+                return pattern ? [pattern] : [];
+            })
+            : Array.from(this.patterns.values());
+        patternsToMatch.forEach((pattern) => {
+            const matches = pattern.match(tokens);
+            if (matches) {
+                allMatches.push(...matches);
+            }
+        });
+        return allMatches;
+    }
+    /**
+     * Tokenize code into analyzable tokens
+     */
+    tokenize(code) {
+        const cacheKey = code.substring(0, 100); // Cache based on first 100 chars
+        const cachedTokens = this.tokenCache.get(cacheKey);
+        if (cachedTokens) {
+            return cachedTokens;
+        }
+        const tokens = [];
+        const lines = code.split("\n");
+        lines.forEach((line, lineNum) => {
+            // Tokenize each line
+            const lineTokens = this.tokenizeLine(line, lineNum);
+            tokens.push(...lineTokens);
+        });
+        this.tokenCache.set(cacheKey, tokens);
+        return tokens;
+    }
+    /**
+     * Tokenize a single line
+     */
+    tokenizeLine(line, lineNum) {
+        const tokens = [];
+        // Simple tokenization - split by whitespace and operators
+        const regex = /(\w+|\[|\]|[{}();,.]|=>|===|==|=|!==|!=|<=|>=|<|>|\+\+|--|\+|-|\*|\/|&&|\|\||!)/g;
+        let match;
+        while ((match = regex.exec(line)) !== null) {
+            const token = match[0];
+            const type = this.getTokenType(token);
+            tokens.push({
+                text: token,
+                type: type,
+                pos: this.getPartOfSpeech(token, type),
+                line: lineNum,
+                index: match.index,
+            });
+        }
+        return tokens;
+    }
+    /**
+     * Get token type
+     */
+    getTokenType(token) {
+        // Keywords
+        const keywords = new Set([
+            "function",
+            "class",
+            "const",
+            "let",
+            "var",
+            "if",
+            "else",
+            "for",
+            "while",
+            "return",
+            "import",
+            "export",
+            "from",
+            "default",
+            "async",
+            "await",
+            "new",
+            "this",
+            "super",
+            "extends",
+            "implements",
+            "interface",
+            "type",
+            "enum",
+            "public",
+            "private",
+            "protected",
+            "static",
+        ]);
+        if (keywords.has(token))
+            return "KEYWORD";
+        if (/^[A-Z]/.test(token))
+            return "CLASS_NAME";
+        if (/^\d+$/.test(token))
+            return "NUMBER";
+        if (/^[a-z_]\w*$/.test(token))
+            return "IDENTIFIER";
+        if (/^[{}[\]()]$/.test(token))
+            return "BRACKET";
+        if (/^[;,.]$/.test(token))
+            return "PUNCTUATION";
+        if (/^(=>|===|==|=|!==|!=|<=|>=|<|>|\+\+|--|\+|-|\*|\/|&&|\|\||!)$/.test(token))
+            return "OPERATOR";
+        return "UNKNOWN";
+    }
+    /**
+     * Get part of speech (simplified for code)
+     */
+    getPartOfSpeech(token, type) {
+        if (type === "KEYWORD") {
+            if (["function", "class", "const", "let", "var"].includes(token)) {
+                return "DECL"; // Declaration
+            }
+            if (["if", "else", "for", "while", "return"].includes(token)) {
+                return "CTRL"; // Control flow
+            }
+        }
+        if (type === "IDENTIFIER")
+            return "NOUN";
+        if (type === "OPERATOR")
+            return "VERB";
+        return type;
+    }
+    /**
+     * Clear token cache
+     */
+    clearCache() {
+        this.tokenCache.clear();
+    }
+}
+// Pre-defined patterns for common code structures
+export const CommonPatterns = {
+    // Function declaration: function name() {}
+    FUNCTION_DECLARATION: [
+        { type: "KEYWORD", text: "function" },
+        { type: "IDENTIFIER" },
+        { type: "BRACKET", text: "(" },
+    ],
+    // Class declaration: class Name
+    CLASS_DECLARATION: [
+        { type: "KEYWORD", text: "class" },
+        { type: "CLASS_NAME" },
+    ],
+    // Class with inheritance: class Name extends Parent
+    CLASS_INHERITANCE: [
+        { type: "KEYWORD", text: "class" },
+        { type: "CLASS_NAME" },
+        { type: "KEYWORD", text: "extends" },
+        { type: "CLASS_NAME" },
+    ],
+    // Variable declaration: const name =
+    VARIABLE_DECLARATION: [
+        { type: "KEYWORD", text: ["const", "let", "var"] },
+        { type: "IDENTIFIER" },
+        { type: "OPERATOR", text: "=" },
+    ],
+    // Import statement: import X from 'Y'
+    IMPORT_STATEMENT: [
+        { type: "KEYWORD", text: "import" },
+        { type: "IDENTIFIER" },
+        { type: "KEYWORD", text: "from" },
+    ],
+    // Method call: object.method()
+    METHOD_CALL: [
+        { type: "IDENTIFIER" },
+        { type: "PUNCTUATION", text: "." },
+        { type: "IDENTIFIER" },
+        { type: "BRACKET", text: "(" },
+    ],
+    // Arrow function: () =>
+    ARROW_FUNCTION: [
+        { type: "BRACKET", text: "(" },
+        { type: "BRACKET", text: ")" },
+        { type: "OPERATOR", text: "=>" },
+    ],
+    // Async function: async function
+    ASYNC_FUNCTION: [
+        { type: "KEYWORD", text: "async" },
+        { type: "KEYWORD", text: "function" },
+    ],
+    // Interface implementation: class X implements Y
+    INTERFACE_IMPLEMENTATION: [
+        { type: "KEYWORD", text: "class" },
+        { type: "CLASS_NAME" },
+        { type: "KEYWORD", text: "implements" },
+    ],
+    // Constructor: constructor()
+    CONSTRUCTOR: [
+        { type: "IDENTIFIER", text: "constructor" },
+        { type: "BRACKET", text: "(" },
+    ],
+};
+// Create a default matcher with common patterns
+export function createDefaultMatcher() {
+    const matcher = new CodeMatcher();
+    Object.entries(CommonPatterns).forEach(([name, rules]) => {
+        matcher.addPattern(name, rules);
+    });
+    return matcher;
+}
+export default CodeMatcher;

package/dist/api/core/library/regexEscape.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Escape a string so it can be used as a literal in a JavaScript RegExp.
+ */
+export declare const escapeRegExp: (value: string) => string;

package/dist/api/core/library/regexEscape.js

@@ -0,0 +1,4 @@
+/**
+ * Escape a string so it can be used as a literal in a JavaScript RegExp.
+ */
+export const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

package/dist/api/core/library/runtimeEventBus.d.ts

@@ -0,0 +1,27 @@
+type RuntimeEventListener = (data?: unknown) => void;
+declare class RuntimeEventBus {
+    listeners: Map<string, Set<RuntimeEventListener>>;
+    buffer: Map<string, unknown>;
+    eventHistory: Array<{
+        event: string;
+        timestamp: number;
+        dataSize: number;
+    }>;
+    maxHistorySize: number;
+    subscribe(event: string, listener: RuntimeEventListener): () => void;
+    emit(event: string, data?: unknown): void;
+    trackEvent(event: string, data: unknown): void;
+    getStatistics(): Record<string, number>;
+    clear(): void;
+}
+export declare const runtimeEventBus: RuntimeEventBus;
+export declare const RuntimeEvents: {
+    readonly FILE_OPEN: "file:open";
+    readonly CODE_CHANGE: "code:change";
+    readonly CONTEXT_UPDATE: "kg:context:update";
+    readonly CONTEXT_QUERY: "kg:context:query";
+    readonly TOKEN_USAGE: "kg:token:usage";
+    readonly CACHE_HIT: "kg:cache:hit";
+    readonly CACHE_MISS: "kg:cache:miss";
+};
+export default RuntimeEventBus;