@4onstudios/iris-agent 0.1.0

package/dist/api/core/containers/chat/toolResultSerialization.d.ts

@@ -0,0 +1,8 @@
+export type SerializableToolResult = {
+    tool?: string;
+    name?: string;
+    status?: string;
+    result?: unknown;
+};
+export declare const serializeToolResultForContinuation: (toolResult: SerializableToolResult, unknownToolLabel?: string) => string;
+export declare const serializeToolResultsForContinuation: (toolResults: SerializableToolResult[], unknownToolLabel?: string) => string;

package/dist/api/core/containers/chat/toolResultSerialization.js

@@ -0,0 +1,71 @@
+const MAX_RESULT_CHARS = 12_000;
+const MAX_CONTINUATION_CHARS = 240_000;
+const TRUNCATION_MARKER = "\n[truncated for final-answer synthesis]";
+const truncateForContinuation = (value, maxChars) => {
+    if (value.length <= maxChars)
+        return value;
+    return `${value.slice(0, Math.max(0, maxChars - TRUNCATION_MARKER.length))}${TRUNCATION_MARKER}`;
+};
+const toRecord = (value) => {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    return value;
+};
+const firstNonEmptyString = (...values) => {
+    for (const value of values) {
+        if (typeof value === "string") {
+            const trimmed = value.trim();
+            if (trimmed.length > 0) {
+                return trimmed;
+            }
+        }
+    }
+    return "";
+};
+export const serializeToolResultForContinuation = (toolResult, unknownToolLabel = "unknown_tool") => {
+    const toolName = toolResult.tool || toolResult.name || unknownToolLabel;
+    const rawResult = toRecord(toolResult.result) || {};
+    const nestedValue = toRecord(rawResult.value);
+    const status = firstNonEmptyString(toolResult.status, rawResult.status, nestedValue?.status) || "completed";
+    const output = firstNonEmptyString(rawResult.output, rawResult.content, rawResult.text, rawResult.stdout, rawResult.stderr, nestedValue?.output, nestedValue?.content, nestedValue?.text, nestedValue?.stdout, nestedValue?.stderr);
+    const error = firstNonEmptyString(rawResult.error, nestedValue?.error);
+    const resultPath = firstNonEmptyString(rawResult.filePath, rawResult.path, nestedValue?.filePath, nestedValue?.path);
+    const exitCode = typeof rawResult.exitCode !== "undefined"
+        ? rawResult.exitCode
+        : typeof nestedValue?.exitCode !== "undefined"
+            ? nestedValue.exitCode
+            : undefined;
+    const indicatesFailure = rawResult.success === false ||
+        nestedValue?.success === false ||
+        (typeof exitCode === "number" && exitCode !== 0);
+    const displayStatus = indicatesFailure ? "failed" : status;
+    const parts = [
+        `Tool: ${toolName}`,
+        `Status: ${displayStatus}`,
+        resultPath ? `Path: ${resultPath}` : "",
+        typeof exitCode !== "undefined" ? `ExitCode: ${String(exitCode)}` : "",
+        error ? `Error: ${error}` : "",
+        output ? `Output:\n${output}` : "",
+        `ResultJSON:\n${JSON.stringify(toolResult.result ?? {}, null, 2)}`,
+    ].filter((part) => part.length > 0);
+    return truncateForContinuation(parts.join("\n"), MAX_RESULT_CHARS);
+};
+export const serializeToolResultsForContinuation = (toolResults, unknownToolLabel = "unknown_tool") => {
+    const serializedResults = toolResults.map((toolResult) => serializeToolResultForContinuation(toolResult, unknownToolLabel));
+    const selected = [];
+    let remainingChars = MAX_CONTINUATION_CHARS;
+    for (let index = serializedResults.length - 1; index >= 0; index -= 1) {
+        const separatorChars = selected.length > 0 ? 2 : 0;
+        const result = serializedResults[index];
+        if (result.length + separatorChars > remainingChars)
+            break;
+        selected.unshift(result);
+        remainingChars -= result.length + separatorChars;
+    }
+    const omittedCount = serializedResults.length - selected.length;
+    const omissionNotice = omittedCount > 0
+        ? `[${omittedCount} older tool result${omittedCount === 1 ? "" : "s"} omitted for payload safety]\n\n`
+        : "";
+    return `${omissionNotice}${selected.join("\n\n")}`;
+};

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

@@ -0,0 +1,11 @@
+import type { Browser, Page } from "puppeteer";
+declare class BrowserManager {
+    static instance: BrowserManager | null;
+    static initPromise: Promise<void> | null;
+    browser: Browser | null;
+    static getInstance(): Promise<BrowserManager>;
+    init(): Promise<void>;
+    newPage(): Promise<Page>;
+    close(): Promise<void>;
+}
+export default BrowserManager;

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

@@ -0,0 +1,66 @@
+//creating a class to manage the browsing activities and how it will be handled
+class BrowserManager {
+    static instance = null;
+    static initPromise = null; // shared promise so concurrent callers all await the same init
+    browser = null;
+    static async getInstance() {
+        if (!BrowserManager.initPromise) {
+            BrowserManager.initPromise = (async () => {
+                BrowserManager.instance = new BrowserManager();
+                await BrowserManager.instance.init();
+            })().catch((err) => {
+                // Reset so the next caller can attempt initialization again
+                BrowserManager.initPromise = null;
+                BrowserManager.instance = null;
+                throw err;
+            });
+        }
+        await BrowserManager.initPromise;
+        if (!BrowserManager.instance) {
+            throw new Error("Failed to initialize browser manager instance");
+        }
+        return BrowserManager.instance;
+    }
+    async init() {
+        // Running in headless mode so no visible browser window is opened.
+        // --no-sandbox / --disable-setuid-sandbox disable a major Chromium security
+        // boundary and should only be used in constrained environments (e.g. CI/Docker)
+        // where the OS sandbox is unavailable. Set BROWSER_NO_SANDBOX=true to opt in.
+        const { default: puppeteer } = await import("puppeteer");
+        const noSandboxArgs = process.env.BROWSER_NO_SANDBOX === "true"
+            ? ["--no-sandbox", "--disable-setuid-sandbox"]
+            : [];
+        this.browser = await puppeteer.launch({
+            headless: true,
+            args: noSandboxArgs,
+        });
+    }
+    async newPage() {
+        //before create a new page we need to verify of the browser instance is available first
+        //because  a page cannot be created without no browser instance.
+        //if there is none the we return a new page from the browser instance created
+        if (!this.browser) {
+            throw new Error("No Browser instance was found!");
+        }
+        return this.browser.newPage();
+    }
+    //another method of this class to  close the browser instance
+    //after browsing activities are complete.
+    async close() {
+        if (!this.browser) {
+            return;
+        }
+        try {
+            await this.browser.close();
+        }
+        catch (err) {
+            // Ignore errors from browsers that are already closed
+        }
+        finally {
+            this.browser = null;
+            BrowserManager.instance = null;
+            BrowserManager.initPromise = null;
+        }
+    }
+}
+export default BrowserManager;

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

@@ -0,0 +1 @@
+export declare const getDesktopWorkspacePath: () => string | null;

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

@@ -0,0 +1,3 @@
+// The HTTP service has no desktop webview state. Integrating clients must pass
+// the workspace root explicitly with each agent request.
+export const getDesktopWorkspacePath = () => null;

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

@@ -0,0 +1,10 @@
+import { EventEmitter } from "events";
+export declare class ExtensionManager extends EventEmitter {
+    private copilotLanguageServerEnabled;
+    constructor();
+    isCopilotLanguageServerEnabled(): boolean;
+    setCopilotLanguageServerEnabled(enabled: boolean): void;
+    onDidChange(listener: () => void): () => void;
+}
+export declare const extensionManager: ExtensionManager;
+export default ExtensionManager;

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

@@ -0,0 +1,27 @@
+import { EventEmitter } from "events";
+const COPILOT_LANGUAGE_SERVER_FLAG = "IRIS_ENABLE_COPILOT_LANGUAGE_SERVER";
+export class ExtensionManager extends EventEmitter {
+    copilotLanguageServerEnabled;
+    constructor() {
+        super();
+        this.copilotLanguageServerEnabled = process.env[COPILOT_LANGUAGE_SERVER_FLAG] === "true";
+    }
+    isCopilotLanguageServerEnabled() {
+        return this.copilotLanguageServerEnabled;
+    }
+    setCopilotLanguageServerEnabled(enabled) {
+        if (this.copilotLanguageServerEnabled === enabled) {
+            return;
+        }
+        this.copilotLanguageServerEnabled = enabled;
+        this.emit("change");
+    }
+    onDidChange(listener) {
+        this.on("change", listener);
+        return () => {
+            this.off("change", listener);
+        };
+    }
+}
+export const extensionManager = new ExtensionManager();
+export default ExtensionManager;

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

@@ -0,0 +1,268 @@
+/**
+ * Knowledge Graph System for Token Optimization
+ * Implements intelligent context caching and relationship tracking
+ */
+import { createDefaultMatcher } from "./patternMatcher.js";
+export type KnowledgeNodeType = "file" | "function" | "class" | "import" | "context" | "method" | "interface" | "variable";
+export type KnowledgeRelationship = {
+    nodeId: string;
+    type: string;
+    metadata: Record<string, unknown>;
+    timestamp: number;
+    confidence?: number;
+};
+export type KnowledgeMethod = {
+    name: string;
+    isAsync: boolean;
+};
+export type KnowledgeNodeMetadata = Record<string, unknown> & {
+    name?: string;
+    language?: string;
+    path?: string;
+    filePath?: string;
+    startLine?: number;
+    endLine?: number;
+    extends?: string | null;
+    implements?: string[];
+    methods?: KnowledgeMethod[];
+    className?: string;
+    methodName?: string;
+    isAsync?: boolean;
+};
+type RedactionInfo = {
+    count: number;
+    types: string[];
+};
+type KnowledgeComponent = {
+    type: KnowledgeNodeType;
+    name: string;
+    content: string;
+    startLine: number;
+    endLine?: number;
+    dependencies?: string[];
+    calls?: string[];
+    uses?: string[];
+    extends?: string | null;
+    implements?: string[];
+    methods?: KnowledgeMethod[];
+};
+type PatternAnalysis = {
+    patterns: Record<string, unknown[]>;
+    complexity: number;
+    structures: string[];
+};
+export type KnowledgeContext = {
+    nodes: KnowledgeNode[];
+    tokenCount: number;
+    contextText: string;
+    retrieval?: {
+        mode: "entity" | "question";
+        question?: string;
+        anchorNodeIds?: string[];
+        hops?: number;
+        matchedTerms?: string[];
+    };
+};
+type CacheEntry = {
+    context: KnowledgeContext;
+    tokenCount: number;
+    timestamp: number;
+    node?: KnowledgeNode;
+};
+type ContextQuery = {
+    type?: string;
+    id: string;
+    relatedFiles?: string[];
+    maxTokens?: number;
+};
+type QuestionQuery = {
+    question: string;
+    anchorId?: string;
+    relatedFiles?: string[];
+    maxTokens?: number;
+    maxDepth?: number;
+};
+type ScoredNode = {
+    node: KnowledgeNode;
+    score: number;
+};
+type IndexedFile = {
+    path: string;
+    name?: string;
+    content: string;
+    language?: string | null;
+};
+type GraphStatistics = {
+    nodeCount: number;
+    cacheSize: number;
+    cacheHits: number;
+    cacheMisses: number;
+    hitRate: string;
+    totalTokensSaved: number;
+    estimatedCostSaved: string;
+};
+type ExportGraphNode = {
+    id: string;
+    type: string;
+    label: string;
+    size: number;
+    accessCount: number;
+};
+type ExportGraphEdge = {
+    source: string;
+    target: string;
+    type: string;
+};
+type ExportGraph = {
+    nodes: ExportGraphNode[];
+    edges: ExportGraphEdge[];
+};
+/**
+ * Knowledge Node - Represents a piece of code context
+ */
+export declare class KnowledgeNode {
+    id: string;
+    type: KnowledgeNodeType;
+    content: string;
+    originalContent: string | null;
+    redacted: boolean;
+    redactionInfo: RedactionInfo | null;
+    metadata: KnowledgeNodeMetadata;
+    relationships: Set<KnowledgeRelationship>;
+    accessCount: number;
+    lastAccessed: number;
+    tokenCount: number;
+    embedding: unknown;
+    constructor(id: string, type: KnowledgeNodeType, content: string, metadata?: KnowledgeNodeMetadata);
+    estimateTokens(text: string): number;
+    addRelationship(nodeId: string, relationshipType: string, metadata?: Record<string, unknown>, confidence?: number): void;
+    hasRelationship(nodeId: string, relationshipType: string): boolean;
+    getRelationships(type?: string | null): KnowledgeRelationship[];
+    access(): void;
+    get score(): number;
+}
+/**
+ * Knowledge Graph - Manages code context and relationships
+ */
+declare class KnowledgeGraph {
+    nodes: Map<string, KnowledgeNode>;
+    cache: Map<string, CacheEntry>;
+    maxCacheSize: number;
+    totalTokensSaved: number;
+    cacheHits: number;
+    cacheMisses: number;
+    patternMatcher: ReturnType<typeof createDefaultMatcher>;
+    constructor();
+    initializeEventListeners(): void;
+    /**
+     * Create or update a node
+     */
+    upsertNode(id: string, type: KnowledgeNodeType, content: string, metadata?: KnowledgeNodeMetadata): KnowledgeNode;
+    /**
+     * Index a file and its components
+     */
+    indexFile(file: IndexedFile): void;
+    normalizePathLike(input: string): string;
+    resolveImportPath(sourceFilePath: string, importPath: string): string;
+    /**
+     * Parse code components (functions, classes, imports)
+     */
+    parseComponents(content: string, language?: string | null): KnowledgeComponent[];
+    /**
+     * Enhanced: Extract function calls from code
+     */
+    extractFunctionCalls(code: string): string[];
+    /**
+     * Enhanced: Extract variable usage from code
+     */
+    extractVariableUsage(code: string): string[];
+    /**
+     * Enhanced: Extract methods from class
+     */
+    extractClassMethods(classCode: string): KnowledgeMethod[];
+    /**
+     * Check if a word is a JavaScript keyword
+     */
+    isKeyword(word: string): boolean;
+    /**
+     * Enhanced: Build semantic relationships between components
+     */
+    buildSemanticRelationships(path: string, components: KnowledgeComponent[]): void;
+    /**
+     * Find a node by name and type
+     */
+    findNodeByName(name: string, type: KnowledgeNodeType): string;
+    /**
+     * Extract code block from position
+     */
+    extractBlock(content: string, startIndex: number): string;
+    /**
+     * Extract statement (for arrow functions, etc.)
+     */
+    extractStatement(content: string, startIndex: number): string;
+    /**
+     * Enhanced: Use pattern matching to analyze code structure
+     */
+    analyzeWithPatterns(code: string): {
+        patterns: Record<string, unknown[]>;
+        complexity: number;
+        structures: string[];
+    };
+    /**
+     * Calculate code complexity score
+     */
+    calculateComplexity(patterns: PatternAnalysis["patterns"]): number;
+    /**
+     * Query context with caching
+     */
+    queryContext(query: ContextQuery): KnowledgeContext;
+    /**
+     * Build context from knowledge graph
+     */
+    buildContext(type: string | undefined, id: string, relatedFiles?: string[], maxTokens?: number): KnowledgeContext;
+    extractQuestionTerms(question: string): string[];
+    scoreNodeForQuestion(node: KnowledgeNode, terms: string[], relatedFiles: string[]): number;
+    findAnchorNodes(question: string, relatedFiles?: string[], limit?: number): {
+        terms: string[];
+        anchors: ScoredNode[];
+    };
+    getRelationshipWeight(type: string): number;
+    collectNeighbors(nodeId: string): {
+        nodeId: string;
+        edgeWeight: number;
+    }[];
+    queryByQuestion(query: QuestionQuery): KnowledgeContext;
+    /**
+     * Update cache with LRU eviction
+     */
+    updateCache(key: string, context: KnowledgeContext): void;
+    /**
+     * Update context when code changes
+     */
+    updateContext(data: {
+        filePath: string;
+        content: string;
+    }): void;
+    /**
+     * Invalidate cache entries related to a file
+     */
+    invalidateCache(filePath: string): void;
+    /**
+     * Detect language from file extension
+     */
+    detectLanguage(filePath: string): string;
+    /**
+      * Get statistics for telemetry
+     */
+    getStatistics(): GraphStatistics;
+    /**
+     * Export graph for visualization
+     */
+    exportGraph(): ExportGraph;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+export declare const knowledgeGraph: KnowledgeGraph;
+export default KnowledgeGraph;