noema-cli 0.0.1

package/dist/acp/handler.js

@@ -0,0 +1,164 @@
+import { ensureSession, generateSessionId } from "./state.js";
+export const handleRequest = (request, state) => {
+    switch (request.method) {
+        case "initialize": {
+            const params = asObject(request.params);
+            const protocolVersion = extractProtocolVersion(params);
+            return {
+                responses: [
+                    {
+                        jsonrpc: "2.0",
+                        id: request.id,
+                        result: {
+                            protocolVersion,
+                            agentCapabilities: {
+                                loadSession: false,
+                                mcpCapabilities: {
+                                    http: false,
+                                    sse: false,
+                                },
+                                promptCapabilities: {
+                                    audio: false,
+                                    embeddedContext: false,
+                                    image: false,
+                                },
+                                sessionCapabilities: {},
+                            },
+                            agentInfo: {
+                                name: "noema-cli",
+                                title: "Noema CLI",
+                                version: "0.0.1",
+                            },
+                            authMethods: [],
+                        },
+                    },
+                ],
+                notifications: [],
+            };
+        }
+        case "session/new": {
+            const sessionId = generateSessionId(state);
+            ensureSession(state, sessionId);
+            return {
+                responses: [
+                    {
+                        jsonrpc: "2.0",
+                        id: request.id,
+                        result: {
+                            sessionId,
+                        },
+                    },
+                ],
+                notifications: [],
+            };
+        }
+        case "session/prompt": {
+            const params = asObject(request.params);
+            const sessionId = typeof params?.sessionId === "string" ? params.sessionId : null;
+            if (sessionId === null) {
+                return invalidParamsResponse(request.id);
+            }
+            ensureSession(state, sessionId);
+            const promptText = extractPromptText(params);
+            const responseText = buildEchoResponse(promptText);
+            const updates = buildStreamingUpdates(sessionId, responseText);
+            return {
+                responses: [
+                    {
+                        jsonrpc: "2.0",
+                        id: request.id,
+                        result: {
+                            stopReason: "end_turn",
+                        },
+                    },
+                ],
+                notifications: updates,
+            };
+        }
+        default:
+            return {
+                responses: [
+                    {
+                        jsonrpc: "2.0",
+                        id: request.id,
+                        error: {
+                            code: -32601,
+                            message: "Method not found",
+                        },
+                    },
+                ],
+                notifications: [],
+            };
+    }
+};
+const asObject = (value) => isRecord(value) ? value : null;
+const isRecord = (value) => typeof value === "object" && value !== null;
+const extractPromptText = (params) => {
+    if (params === null) {
+        return "";
+    }
+    const promptBlocks = Array.isArray(params.prompt) ? params.prompt : [];
+    return promptBlocks.map(extractTextFromBlock).join("");
+};
+const buildEchoResponse = (promptText) => promptText.length === 0 ? "" : `echo: ${promptText}`;
+const buildStreamingUpdates = (sessionId, responseText) => {
+    const chunks = splitResponse(responseText);
+    return chunks.map((chunk) => ({
+        jsonrpc: "2.0",
+        method: "session/update",
+        params: {
+            sessionId,
+            update: {
+                sessionUpdate: "agent_message_chunk",
+                content: {
+                    type: "text",
+                    text: chunk,
+                },
+            },
+        },
+    }));
+};
+const splitResponse = (responseText) => {
+    if (responseText.length === 0) {
+        return [""];
+    }
+    if (responseText.length === 1) {
+        return [responseText];
+    }
+    const midpoint = Math.floor(responseText.length / 2);
+    return [responseText.slice(0, midpoint), responseText.slice(midpoint)];
+};
+const extractTextFromBlock = (block) => {
+    if (!isRecord(block)) {
+        return "";
+    }
+    if (block.type === "text" && typeof block.text === "string") {
+        return block.text;
+    }
+    if (isRecord(block.content)) {
+        const content = block.content;
+        if (content.type === "text" && typeof content.text === "string") {
+            return content.text;
+        }
+    }
+    return "";
+};
+const extractProtocolVersion = (params) => {
+    if (params === null) {
+        return 1;
+    }
+    return typeof params.protocolVersion === "number" ? params.protocolVersion : 1;
+};
+const invalidParamsResponse = (id) => ({
+    responses: [
+        {
+            jsonrpc: "2.0",
+            id,
+            error: {
+                code: -32602,
+                message: "Invalid params",
+            },
+        },
+    ],
+    notifications: [],
+});

package/dist/acp/index.js

@@ -0,0 +1,5 @@
+export const acpAdapterVersion = "0.0.1";
+export { handleRequest } from "./handler.js";
+export { runAcpAdapter } from "./io.js";
+export { createAdapterState } from "./state.js";
+export * from "./types.js";

package/dist/acp/io.js

@@ -0,0 +1,71 @@
+import { createInterface } from "node:readline";
+import { handleRequest } from "./handler.js";
+import { createAdapterState } from "./state.js";
+export const runAcpAdapter = (input = process.stdin, output = process.stdout, state = createAdapterState()) => {
+    const rl = createInterface({ input });
+    rl.on("line", (line) => {
+        const trimmed = line.trim();
+        if (trimmed.length === 0) {
+            return;
+        }
+        let message;
+        try {
+            message = JSON.parse(trimmed);
+        }
+        catch {
+            writeMessage(output, {
+                jsonrpc: "2.0",
+                id: null,
+                error: {
+                    code: -32700,
+                    message: "Parse error",
+                },
+            });
+            return;
+        }
+        if (!isJsonRpcRequest(message)) {
+            if (hasId(message)) {
+                writeMessage(output, {
+                    jsonrpc: "2.0",
+                    id: message.id ?? null,
+                    error: {
+                        code: -32600,
+                        message: "Invalid Request",
+                    },
+                });
+            }
+            return;
+        }
+        const { responses, notifications } = handleRequest(message, state);
+        for (const notification of notifications) {
+            writeMessage(output, notification);
+        }
+        for (const response of responses) {
+            writeMessage(output, response);
+        }
+    });
+};
+const writeMessage = (output, message) => {
+    output.write(`${JSON.stringify(message)}\n`);
+};
+const isJsonRpcRequest = (value) => {
+    if (!isRecord(value)) {
+        return false;
+    }
+    if (value.jsonrpc !== "2.0") {
+        return false;
+    }
+    if (typeof value.method !== "string") {
+        return false;
+    }
+    return hasId(value);
+};
+const hasId = (value) => {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return (typeof value.id === "string" ||
+        typeof value.id === "number" ||
+        value.id === null);
+};
+const isRecord = (value) => typeof value === "object" && value !== null;

package/dist/acp/state.js

@@ -0,0 +1,14 @@
+export const createAdapterState = () => ({
+    nextSessionId: 1,
+    sessions: new Map(),
+});
+export const generateSessionId = (state) => {
+    const id = `session-${state.nextSessionId}`;
+    state.nextSessionId += 1;
+    return id;
+};
+export const ensureSession = (state, sessionId) => {
+    if (!state.sessions.has(sessionId)) {
+        state.sessions.set(sessionId, { id: sessionId });
+    }
+};

package/dist/acp/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/index.js

@@ -0,0 +1 @@
+export const coreVersion = "0.0.1";

package/dist/index.js

@@ -0,0 +1,7 @@
+import { runAcpAdapter } from "./acp/index.js";
+import { runMain } from "./main.js";
+export const cliVersion = "0.0.1";
+export { runMain };
+if (import.meta.url === `file://${process.argv[1]}`) {
+    runMain(runAcpAdapter);
+}

package/dist/main.js

@@ -0,0 +1,3 @@
+export const runMain = (runner) => {
+    runner(process.stdin, process.stdout);
+};

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "noema-cli",
+  "version": "0.0.1",
+  "type": "module",
+  "bin": {
+    "noema-cli": "./dist/index.js"
+  },
+  "exports": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node --test ./tests/*.test.js",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {}
+}