@4onstudios/iris-agent 0.1.0

package/dist/api/routes/lspResolveRoutes.d.ts

@@ -0,0 +1,4 @@
+import type { NextFunction, Request, Response, Router } from "express";
+type AuthMiddleware = (req: Request, res: Response, next: NextFunction) => void;
+export declare const registerLspResolveRoutes: (router: Router, requireDesktopAuth: AuthMiddleware) => void;
+export {};

package/dist/api/routes/lspResolveRoutes.js

@@ -0,0 +1,143 @@
+import path from "path";
+import { coreLsp } from "../core/library/lsp/coreLsp.js";
+const resolveAbsolutePath = (workspacePath, filePath) => {
+    if (typeof filePath !== "string" || filePath.length === 0) {
+        return undefined;
+    }
+    return path.isAbsolute(filePath) ? filePath : path.join(workspacePath, filePath);
+};
+export const registerLspResolveRoutes = (router, requireDesktopAuth) => {
+    router.post("/lsp/completion/resolve", requireDesktopAuth, async (req, res) => {
+        try {
+            const { workspaceRoot, languageId, filePath, item } = req.body;
+            if (!item || typeof item !== "object") {
+                return res.status(400).json({ success: false, error: "item is required" });
+            }
+            const workspacePath = workspaceRoot || process.cwd();
+            coreLsp.setRootPath(workspacePath);
+            const absolutePath = resolveAbsolutePath(workspacePath, filePath);
+            const resolved = await coreLsp.resolveCompletionItem(item, typeof languageId === "string" ? languageId : undefined, absolutePath);
+            return res.json({ success: true, item: resolved });
+        }
+        catch (error) {
+            const err = error;
+            return res
+                .status(500)
+                .json({ success: false, error: err.message || "Failed to resolve completion item" });
+        }
+    });
+    router.post("/lsp/code-action/resolve", requireDesktopAuth, async (req, res) => {
+        try {
+            const { workspaceRoot, languageId, filePath, item } = req.body;
+            if (!item || typeof item !== "object") {
+                return res.status(400).json({ success: false, error: "item is required" });
+            }
+            const workspacePath = workspaceRoot || process.cwd();
+            coreLsp.setRootPath(workspacePath);
+            const absolutePath = resolveAbsolutePath(workspacePath, filePath);
+            const resolved = await coreLsp.resolveCodeAction(item, typeof languageId === "string" ? languageId : undefined, absolutePath);
+            return res.json({ success: true, item: resolved });
+        }
+        catch (error) {
+            const err = error;
+            return res
+                .status(500)
+                .json({ success: false, error: err.message || "Failed to resolve code action" });
+        }
+    });
+    router.post("/lsp/code-lens/resolve", requireDesktopAuth, async (req, res) => {
+        try {
+            const { workspaceRoot, languageId, filePath, item } = req.body;
+            if (!item || typeof item !== "object") {
+                return res.status(400).json({ success: false, error: "item is required" });
+            }
+            const workspacePath = workspaceRoot || process.cwd();
+            coreLsp.setRootPath(workspacePath);
+            const absolutePath = resolveAbsolutePath(workspacePath, filePath);
+            const resolved = await coreLsp.resolveCodeLens(item, typeof languageId === "string" ? languageId : undefined, absolutePath);
+            return res.json({ success: true, item: resolved });
+        }
+        catch (error) {
+            const err = error;
+            return res
+                .status(500)
+                .json({ success: false, error: err.message || "Failed to resolve code lens" });
+        }
+    });
+    router.post("/lsp/document-link/resolve", requireDesktopAuth, async (req, res) => {
+        try {
+            const { workspaceRoot, languageId, filePath, item } = req.body;
+            if (!item || typeof item !== "object") {
+                return res.status(400).json({ success: false, error: "item is required" });
+            }
+            const workspacePath = workspaceRoot || process.cwd();
+            coreLsp.setRootPath(workspacePath);
+            const absolutePath = resolveAbsolutePath(workspacePath, filePath);
+            const resolved = await coreLsp.resolveDocumentLink(item, typeof languageId === "string" ? languageId : undefined, absolutePath);
+            return res.json({ success: true, item: resolved });
+        }
+        catch (error) {
+            const err = error;
+            return res
+                .status(500)
+                .json({ success: false, error: err.message || "Failed to resolve document link" });
+        }
+    });
+    router.post("/lsp/workspace-symbol/resolve", requireDesktopAuth, async (req, res) => {
+        try {
+            const { workspaceRoot, languageId, item } = req.body;
+            if (!item || typeof item !== "object") {
+                return res.status(400).json({ success: false, error: "item is required" });
+            }
+            const workspacePath = workspaceRoot || process.cwd();
+            coreLsp.setRootPath(workspacePath);
+            const resolved = await coreLsp.resolveWorkspaceSymbol(item, typeof languageId === "string" ? languageId : undefined);
+            return res.json({ success: true, item: resolved });
+        }
+        catch (error) {
+            const err = error;
+            return res
+                .status(500)
+                .json({ success: false, error: err.message || "Failed to resolve workspace symbol" });
+        }
+    });
+    router.post("/lsp/inlay-hint/resolve", requireDesktopAuth, async (req, res) => {
+        try {
+            const { workspaceRoot, languageId, filePath, item } = req.body;
+            if (!item || typeof item !== "object") {
+                return res.status(400).json({ success: false, error: "item is required" });
+            }
+            const workspacePath = workspaceRoot || process.cwd();
+            coreLsp.setRootPath(workspacePath);
+            const absolutePath = resolveAbsolutePath(workspacePath, filePath);
+            const resolved = await coreLsp.resolveInlayHint(item, typeof languageId === "string" ? languageId : undefined, absolutePath);
+            return res.json({ success: true, item: resolved });
+        }
+        catch (error) {
+            const err = error;
+            return res
+                .status(500)
+                .json({ success: false, error: err.message || "Failed to resolve inlay hint" });
+        }
+    });
+    router.post("/lsp/inline-completion/resolve", requireDesktopAuth, async (req, res) => {
+        try {
+            const { workspaceRoot, languageId, filePath, item } = req.body;
+            if (!item || typeof item !== "object") {
+                return res.status(400).json({ success: false, error: "item is required" });
+            }
+            const workspacePath = workspaceRoot || process.cwd();
+            coreLsp.setRootPath(workspacePath);
+            const absolutePath = resolveAbsolutePath(workspacePath, filePath);
+            const resolved = await coreLsp.resolveInlineCompletionItem(item, typeof languageId === "string" ? languageId : undefined, absolutePath);
+            return res.json({ success: true, item: resolved });
+        }
+        catch (error) {
+            const err = error;
+            return res.status(500).json({
+                success: false,
+                error: err.message || "Failed to resolve inline completion item",
+            });
+        }
+    });
+};

package/dist/api/routes/lspSemanticDocumentRoutes.d.ts

@@ -0,0 +1,4 @@
+import type { NextFunction, Request, Response, Router } from "express";
+type AuthMiddleware = (req: Request, res: Response, next: NextFunction) => void;
+export declare const registerLspSemanticDocumentRoutes: (router: Router, requireDesktopAuth: AuthMiddleware) => void;
+export {};

package/dist/api/routes/lspSemanticDocumentRoutes.js

@@ -0,0 +1,98 @@
+import path from "path";
+import { coreLsp } from "../core/library/lsp/coreLsp.js";
+const resolveAbsolutePath = (workspacePath, filePath) => path.isAbsolute(filePath) ? filePath : path.join(workspacePath, filePath);
+export const registerLspSemanticDocumentRoutes = (router, requireDesktopAuth) => {
+    router.post("/lsp/semantic-tokens-range", requireDesktopAuth, async (req, res) => {
+        try {
+            const { filePath, workspaceRoot, startLine, startCharacter, endLine, endCharacter, } = req.body;
+            if (typeof filePath !== "string" || filePath.trim().length === 0) {
+                return res.status(400).json({ success: false, error: "filePath is required" });
+            }
+            if (typeof startLine !== "number" ||
+                typeof startCharacter !== "number" ||
+                typeof endLine !== "number" ||
+                typeof endCharacter !== "number") {
+                return res.status(400).json({
+                    success: false,
+                    error: "startLine, startCharacter, endLine, and endCharacter are required",
+                });
+            }
+            const workspacePath = workspaceRoot || process.cwd();
+            const absolutePath = resolveAbsolutePath(workspacePath, filePath);
+            coreLsp.setRootPath(workspacePath);
+            const semanticTokens = await coreLsp.getSemanticTokensRange(absolutePath, startLine, startCharacter, endLine, endCharacter);
+            if (!semanticTokens) {
+                return res.json({ success: false, error: "No semantic tokens available" });
+            }
+            return res.json({
+                success: true,
+                data: semanticTokens.data,
+                legend: semanticTokens.legend,
+                languageId: semanticTokens.languageId,
+            });
+        }
+        catch (error) {
+            const err = error;
+            return res
+                .status(500)
+                .json({ success: false, error: err.message || "Failed to get semantic tokens" });
+        }
+    });
+    router.post("/lsp/semantic-tokens-full", requireDesktopAuth, async (req, res) => {
+        try {
+            const { filePath, workspaceRoot } = req.body;
+            if (typeof filePath !== "string" || filePath.trim().length === 0) {
+                return res.status(400).json({ success: false, error: "filePath is required" });
+            }
+            const workspacePath = workspaceRoot || process.cwd();
+            const absolutePath = resolveAbsolutePath(workspacePath, filePath);
+            coreLsp.setRootPath(workspacePath);
+            const semanticTokens = await coreLsp.getSemanticTokensFull(absolutePath);
+            if (!semanticTokens) {
+                return res.json({ success: false, error: "No semantic tokens available" });
+            }
+            return res.json({
+                success: true,
+                data: semanticTokens.data,
+                resultId: semanticTokens.resultId,
+                legend: semanticTokens.legend,
+                languageId: semanticTokens.languageId,
+            });
+        }
+        catch (error) {
+            const err = error;
+            return res
+                .status(500)
+                .json({ success: false, error: err.message || "Failed to get semantic tokens" });
+        }
+    });
+    router.post("/lsp/semantic-tokens-delta", requireDesktopAuth, async (req, res) => {
+        try {
+            const { filePath, workspaceRoot, previousResultId } = req.body;
+            if (typeof filePath !== "string" || filePath.trim().length === 0) {
+                return res.status(400).json({ success: false, error: "filePath is required" });
+            }
+            const workspacePath = workspaceRoot || process.cwd();
+            const absolutePath = resolveAbsolutePath(workspacePath, filePath);
+            coreLsp.setRootPath(workspacePath);
+            const semanticTokens = await coreLsp.getSemanticTokensDocumentDelta(absolutePath, typeof previousResultId === "string" ? previousResultId : undefined);
+            if (!semanticTokens) {
+                return res.json({ success: false, error: "No semantic token delta available" });
+            }
+            return res.json({
+                success: true,
+                data: semanticTokens.data,
+                resultId: semanticTokens.resultId,
+                edits: semanticTokens.edits,
+                legend: semanticTokens.legend,
+                languageId: semanticTokens.languageId,
+            });
+        }
+        catch (error) {
+            const err = error;
+            return res
+                .status(500)
+                .json({ success: false, error: err.message || "Failed to get semantic token delta" });
+        }
+    });
+};

package/dist/api/routes/semanticRoutes.d.ts

@@ -0,0 +1,2 @@
+import type { Router } from "express";
+export declare const registerSemanticRoutes: (router: Router) => void;

package/dist/api/routes/semanticRoutes.js

@@ -0,0 +1,126 @@
+import path from "path";
+import { coreLsp } from "../core/library/lsp/coreLsp.js";
+const LANGUAGE_ID_MAP = {
+    ts: "typescript",
+    tsx: "typescriptreact",
+    typescript: "typescript",
+    typescriptreact: "typescriptreact",
+    js: "javascript",
+    jsx: "javascriptreact",
+    javascript: "javascript",
+    javascriptreact: "javascriptreact",
+    py: "python",
+    python: "python",
+};
+const resolveSemanticLanguageId = (language) => LANGUAGE_ID_MAP[language.toLowerCase()];
+const resolveSemanticFilePath = ({ filePath, workspacePath, languageId, }) => {
+    if (filePath) {
+        return path.isAbsolute(filePath) ? filePath : path.join(workspacePath, filePath);
+    }
+    return path.join(workspacePath, `.iris-semantic-preview.${languageId.startsWith("typescript")
+        ? "ts"
+        : languageId === "python"
+            ? "py"
+            : "js"}`);
+};
+export const registerSemanticRoutes = (router) => {
+    // POST /api/agent/semantic-tokens - Get semantic tokens for supported LSP snippets
+    router.post("/semantic-tokens", async (req, res) => {
+        try {
+            const { code, language, filePath, workspaceRoot } = req.body;
+            if (typeof code !== "string") {
+                return res.status(400).json({ success: false, error: "Code is required" });
+            }
+            if (typeof language !== "string" || language.length === 0) {
+                return res.status(400).json({ success: false, error: "Language is required" });
+            }
+            const languageId = resolveSemanticLanguageId(language);
+            if (!languageId) {
+                return res.status(400).json({
+                    success: false,
+                    error: `Semantic tokens are not supported for language: ${language}`,
+                });
+            }
+            const workspacePath = workspaceRoot || process.cwd();
+            const semanticFilePath = resolveSemanticFilePath({
+                filePath,
+                workspacePath,
+                languageId,
+            });
+            coreLsp.setRootPath(workspacePath);
+            const semanticTokens = await coreLsp.getSemanticTokensForCode(semanticFilePath, languageId, code);
+            if (!semanticTokens) {
+                // Distinguish "the language server can never start here" from a
+                // transient cold-start miss so the client knows not to retry.
+                const unavailable = coreLsp.isLanguageUnavailable(languageId);
+                return res.json({
+                    success: false,
+                    unavailable,
+                    error: unavailable
+                        ? `No language server available for ${languageId} in this workspace`
+                        : "No semantic tokens available",
+                });
+            }
+            return res.json({
+                success: true,
+                data: semanticTokens.data,
+                legend: semanticTokens.legend,
+                languageId: semanticTokens.languageId,
+            });
+        }
+        catch (error) {
+            const err = error;
+            console.error("Semantic tokens error:", error);
+            return res.status(500).json({
+                success: false,
+                error: err.message || "Failed to fetch semantic tokens",
+            });
+        }
+    });
+    // POST /api/agent/semantic-tokens-delta - Get semantic token deltas for supported LSP snippets
+    router.post("/semantic-tokens-delta", async (req, res) => {
+        try {
+            const { code, language, filePath, workspaceRoot, previousResultId } = req.body;
+            if (typeof code !== "string") {
+                return res.status(400).json({ success: false, error: "Code is required" });
+            }
+            if (typeof language !== "string" || language.length === 0) {
+                return res.status(400).json({ success: false, error: "Language is required" });
+            }
+            const languageId = resolveSemanticLanguageId(language);
+            if (!languageId) {
+                return res.status(400).json({
+                    success: false,
+                    error: `Semantic tokens are not supported for language: ${language}`,
+                });
+            }
+            const workspacePath = workspaceRoot || process.cwd();
+            const semanticFilePath = resolveSemanticFilePath({
+                filePath,
+                workspacePath,
+                languageId,
+            });
+            coreLsp.setRootPath(workspacePath);
+            const semanticTokens = await coreLsp.getSemanticTokensDelta(semanticFilePath, languageId, code, typeof previousResultId === "string" ? previousResultId : undefined);
+            if (!semanticTokens) {
+                return res.json({ success: false, error: "No semantic tokens available" });
+            }
+            return res.json({
+                success: true,
+                data: semanticTokens.data,
+                edits: semanticTokens.edits,
+                resultId: semanticTokens.resultId,
+                legend: semanticTokens.legend,
+                languageId: semanticTokens.languageId,
+            });
+        }
+        catch (error) {
+            const err = error;
+            console.error("Semantic tokens delta error:", error);
+            return res.status(500).json({
+                success: false,
+                error: err.message || "Failed to fetch semantic token delta",
+            });
+        }
+    });
+};

package/dist/cli.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * iris-agent CLI with ACP (Agent Client Protocol) support
+ * Usage:
+ *   iris-agent --workspace /path/to/workspace --modelId openrouter/openai/gpt-4o --acp
+ *   iris-agent --workspace /path/to/workspace --modelId openrouter/openai/gpt-4o --chat
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+/**
+ * iris-agent CLI with ACP (Agent Client Protocol) support
+ * Usage:
+ *   iris-agent --workspace /path/to/workspace --modelId openrouter/openai/gpt-4o --acp
+ *   iris-agent --workspace /path/to/workspace --modelId openrouter/openai/gpt-4o --chat
+ */
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { createCodingAgent } from "./api/core/agent/index.js";
+import { startAcpServer } from "./api/acp/acpServer.js";
+const defaultModelId = process.env.MODEL_ID ||
+    process.env.OPENROUTER_MODEL ||
+    "openrouter/openai/gpt-4o";
+const argv = yargs(hideBin(process.argv))
+    .option("workspace", {
+    alias: "w",
+    type: "string",
+    description: "Workspace root path",
+    required: true,
+})
+    .option("acp", {
+    alias: "a",
+    type: "boolean",
+    description: "Start ACP (Agent Client Protocol) server mode",
+    default: false,
+})
+    .option("chat", {
+    alias: "c",
+    type: "boolean",
+    description: "Interactive chat mode",
+    default: false,
+})
+    .option("modelId", {
+    type: "string",
+    description: "Language model identifier",
+    default: defaultModelId,
+})
+    .help()
+    .parseSync();
+async function main() {
+    const workspaceRoot = argv.workspace;
+    const modelId = argv.modelId;
+    if (argv.acp) {
+        const stderrLog = console.error.bind(console);
+        console.log = stderrLog;
+        console.debug = stderrLog;
+        console.info = stderrLog;
+        console.warn = stderrLog;
+        console.dir = stderrLog;
+        console.table = stderrLog;
+        console.trace = stderrLog;
+        console.group = stderrLog;
+        console.groupCollapsed = stderrLog;
+        console.groupEnd = stderrLog;
+    }
+    console.log(`🚀 Iris Agent CLI`);
+    console.log(`📁 Workspace: ${workspaceRoot}`);
+    console.log(`🤖 Model: ${modelId}`);
+    if (argv.acp) {
+        console.log("🔗 Starting ACP server over stdio...");
+        await startAcpServer((requestedModelId, targetWorkspace) => createCodingAgent(requestedModelId || modelId, targetWorkspace || workspaceRoot), workspaceRoot);
+    }
+    else if (argv.chat) {
+        // Interactive chat mode
+        const agent = await createCodingAgent(modelId, workspaceRoot);
+        console.log(`💬 Entering chat mode (type "exit" to quit)`);
+        await startChatMode(agent, workspaceRoot);
+    }
+    else {
+        // Default: show help
+        yargs(hideBin(process.argv))
+            .showHelp();
+    }
+}
+async function startChatMode(agent, workspaceRoot) {
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const question = (prompt) => new Promise((resolve) => rl.question(prompt, resolve));
+    const threadId = `cli-chat-${Date.now()}`;
+    const resourceId = `cli-session`;
+    try {
+        while (true) {
+            const input = await question("\n> ");
+            const trimmedInput = input.trim();
+            if (!trimmedInput) {
+                continue;
+            }
+            if (trimmedInput.toLowerCase() === "exit" || trimmedInput.toLowerCase() === "quit") {
+                console.log("👋 Goodbye!");
+                break;
+            }
+            try {
+                console.log("🤔 Processing...\n");
+                const options = {
+                    threadId,
+                    resourceId,
+                    maxSteps: 50,
+                    workspaceRoot,
+                };
+                if (typeof agent.stream === "function") {
+                    const streamResult = await agent.stream(trimmedInput, options);
+                    const reader = streamResult.fullStream.getReader();
+                    let hasOutput = false;
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        if (value?.type === "text-delta" || value?.type === "reasoning-delta") {
+                            const text = String(value.payload?.text || "");
+                            if (text) {
+                                process.stdout.write(text);
+                                hasOutput = true;
+                            }
+                        }
+                        else if (value?.type === "tool-call") {
+                            const toolName = typeof value.payload?.toolName === "string"
+                                ? value.payload.toolName
+                                : "tool";
+                            process.stdout.write(`\n⚙️  [Calling tool: ${toolName}]... `);
+                        }
+                        else if (value?.type === "tool-result") {
+                            process.stdout.write(`done.\n`);
+                        }
+                    }
+                    if (!hasOutput && streamResult.text) {
+                        const final = await streamResult.text;
+                        if (final) {
+                            console.log(final);
+                        }
+                    }
+                    console.log();
+                }
+                else if (typeof agent.generate === "function") {
+                    const result = await agent.generate(trimmedInput, options);
+                    const text = typeof result === "string"
+                        ? result
+                        : result?.text || JSON.stringify(result, null, 2);
+                    console.log("\n✅ Agent Response:\n" + text);
+                }
+                else {
+                    throw new Error("Agent does not support streaming or text generation");
+                }
+            }
+            catch (error) {
+                console.error("❌ Error:", error);
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+main().catch((error) => {
+    console.error("❌ Fatal error:", error);
+    process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./api/acp/index.js";

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./api/acp/index.js";

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+import "dotenv/config";
+export declare const app: import("express-serve-static-core").Express;

package/dist/server.js

@@ -0,0 +1,38 @@
+import "dotenv/config";
+import express from "express";
+import agentRouter from "./api/agent.js";
+const port = Number(process.env.PORT || 8080);
+const allowedOrigins = new Set((process.env.AGENT_ALLOWED_ORIGINS || "")
+    .split(",")
+    .map((origin) => origin.trim())
+    .filter(Boolean));
+export const app = express();
+app.disable("x-powered-by");
+app.use((req, res, next) => {
+    const origin = req.get("origin");
+    if (!origin) {
+        return next();
+    }
+    if (!allowedOrigins.has(origin)) {
+        return res.status(403).json({ error: "Origin is not allowed" });
+    }
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    res.setHeader("Vary", "Origin");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, X-Desktop-Token");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    if (req.method === "OPTIONS") {
+        return res.sendStatus(204);
+    }
+    return next();
+});
+app.use(express.json({ limit: "10mb" }));
+app.use(express.urlencoded({ extended: true, limit: "10mb" }));
+app.get("/health", (_req, res) => {
+    res.json({ status: "ok" });
+});
+app.use("/api/agent", agentRouter);
+if (import.meta.url === new URL(process.argv[1], "file:").href) {
+    app.listen(port, () => {
+        console.log(`Iris Agent listening on port ${port}`);
+    });
+}