arcane-agents 0.1.0

package/dist/server/server/status/activityParser.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseActivity = parseActivity;
+const types_1 = require("./engine/types");
+const toolMatchers = [
+    { tool: "read", label: "Reading", regex: /\b(Read|Reading)\b/i },
+    { tool: "edit", label: "Editing", regex: /\b(Edit|Patch|apply_patch|Update File)\b/i },
+    { tool: "write", label: "Writing", regex: /\b(Write|Add File|Created file|Creating file)\b/i },
+    { tool: "grep", label: "Searching", regex: /\b(Grep|ripgrep|\brg\b|searching)\b/i },
+    { tool: "glob", label: "Scanning", regex: /\b(Glob|scan files|file pattern)\b/i },
+    { tool: "bash", label: "Running", regex: /\b(Bash|npm\b|pnpm\b|yarn\b|pytest\b|cargo\b|go\s+test|git\b)\b/i },
+    { tool: "task", label: "Subtask", regex: /\b(Task|subagent|agent)\b/i },
+    { tool: "todo", label: "Planning", regex: /\b(TodoWrite|todo\b)\b/i },
+    { tool: "web", label: "Fetching", regex: /\b(WebFetch|http|https)\b/i },
+    { tool: "terminal", label: "Terminal", regex: /\b(claude|terminal|tmux)\b/i }
+];
+const inputPromptLineMatchers = [
+    /\[(?:Y\/n|y\/N|y\/n|N\/y)\]\s*$/i,
+    /\b(?:press enter|press any key)\b/i,
+    /\b(?:waiting for input|awaiting input|awaiting confirmation)\b/i,
+    /\b(?:select (?:an )?option|enter choice|choose (?:an )?option)\b[:?]?\s*$/i,
+    /\b(?:allow|approve|confirm|continue|proceed)\b[^\n]{0,40}\?\s*$/i
+];
+const generalInputPromptRecentLineWindow = 6;
+const permissionPromptRecentLineWindow = 18;
+const errorLineMatchers = [
+    /\btraceback\b/i,
+    /\bexception\b/i,
+    /\berror:\b/i,
+    /^\s*(?:error|err)\b/i,
+    /\bnpm err!\b/i,
+    /\bcommand not found\b/i,
+    /\bno such file or directory\b/i,
+    /\bpermission denied\b/i,
+    /\bsigterm\b/i,
+    /\bpanic\b/i,
+    /\bfatal\b/i,
+    /\bfailed\b(?:\s+with|\s+to|:)/i
+];
+const filePathRegex = /(?:^|\s|"|')((?:~|\.|\.\.|\/)?(?:[A-Za-z0-9._-]+\/)*[A-Za-z0-9._-]+\.[A-Za-z][A-Za-z0-9_-]{0,7})(?=$|\s|"|'|:|,|\))/;
+function parseActivity(currentCommand, output) {
+    const lines = output
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .slice(-80);
+    const newestFirst = [...lines].reverse();
+    const needsInput = hasInputPromptSignal(newestFirst);
+    const hasError = hasErrorSignal(newestFirst);
+    const toolResult = findTool(newestFirst);
+    const filePath = findFilePath(newestFirst);
+    const fallbackLine = newestFirst.find((line) => line.length > 3 && !line.startsWith("[") && !isRuntimeHintLine(line));
+    const activityText = toolResult && filePath
+        ? `${toolResult.label} ${filePath}`
+        : toolResult
+            ? `${toolResult.label}`
+            : filePath
+                ? `Working on ${filePath}`
+                : fallbackLine;
+    const status = deriveStatus(currentCommand, needsInput, hasError);
+    return {
+        status,
+        activity: {
+            text: activityText,
+            tool: toolResult?.tool,
+            filePath,
+            needsInput,
+            hasError
+        }
+    };
+}
+function hasInputPromptSignal(linesNewestFirst) {
+    const latest = linesNewestFirst[0] ?? "";
+    const secondLatest = linesNewestFirst[1] ?? "";
+    if (isInputPromptLine(latest)) {
+        return true;
+    }
+    if (isShellPromptLine(latest) && isInputPromptLine(secondLatest)) {
+        return true;
+    }
+    for (const line of linesNewestFirst.slice(0, generalInputPromptRecentLineWindow)) {
+        if (isInputPromptLine(line)) {
+            return true;
+        }
+    }
+    return hasPermissionRequiredPromptSignal(linesNewestFirst.slice(0, permissionPromptRecentLineWindow));
+}
+function hasPermissionRequiredPromptSignal(linesNewestFirst) {
+    const recent = linesNewestFirst
+        .map((line) => normalizeStatusLine(line))
+        .map((line) => line.toLowerCase())
+        .filter((line) => line.length > 0);
+    if (!recent.some((line) => line.includes("permission required"))) {
+        return false;
+    }
+    const hasAllowOnce = recent.some((line) => line.includes("allow once"));
+    const hasAllowAlways = recent.some((line) => line.includes("allow always"));
+    const hasReject = recent.some((line) => /\breject\b/.test(line));
+    const hasAccessScope = recent.some((line) => line.includes("access external directory") || line.includes("access external") || line.includes("patterns"));
+    const hasConfirmHint = recent.some((line) => line.includes("enter confirm"));
+    if (hasAllowOnce && hasAllowAlways && hasReject) {
+        return true;
+    }
+    if (hasAccessScope && hasAllowOnce && hasReject) {
+        return true;
+    }
+    return hasAccessScope && hasConfirmHint;
+}
+function isInputPromptLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.length > 220) {
+        return false;
+    }
+    return inputPromptLineMatchers.some((matcher) => matcher.test(trimmed));
+}
+function isShellPromptLine(line) {
+    return /[$#>]\s*$/.test(line.trimEnd());
+}
+function findTool(linesNewestFirst) {
+    for (const line of linesNewestFirst) {
+        for (const matcher of toolMatchers) {
+            if (matcher.regex.test(line)) {
+                return matcher;
+            }
+        }
+    }
+    return undefined;
+}
+function findFilePath(linesNewestFirst) {
+    for (const line of linesNewestFirst) {
+        const match = line.match(filePathRegex);
+        if (!match) {
+            continue;
+        }
+        const candidate = match[1];
+        if (candidate) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function isRuntimeHintLine(line) {
+    const normalized = line.trim().toLowerCase();
+    return normalized.includes("ctrl+t variants") || normalized.includes("ctrl+p commands") || normalized.includes("tab agents");
+}
+function hasErrorSignal(linesNewestFirst) {
+    for (const line of linesNewestFirst.slice(0, 20)) {
+        const normalized = normalizeStatusLine(line);
+        if (!normalized || isRuntimeHintLine(normalized)) {
+            continue;
+        }
+        if (errorLineMatchers.some((matcher) => matcher.test(normalized))) {
+            return true;
+        }
+    }
+    return false;
+}
+function normalizeStatusLine(line) {
+    return line.replace(/^[\s│┃╹▀▣⬝■]+/, "").trim();
+}
+function deriveStatus(currentCommand, needsInput, hasError) {
+    if (needsInput) {
+        return "attention";
+    }
+    if (hasError) {
+        return "error";
+    }
+    if (types_1.shellCommands.has(currentCommand.toLowerCase())) {
+        return "idle";
+    }
+    return "working";
+}

package/dist/server/server/status/claudeTranscript/accumulator.js

@@ -0,0 +1,372 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTranscriptState = createTranscriptState;
+exports.resetTranscriptState = resetTranscriptState;
+exports.applyParsedTranscriptRecords = applyParsedTranscriptRecords;
+exports.normalizeToolName = normalizeToolName;
+const node_path_1 = __importDefault(require("node:path"));
+const constants_1 = require("./constants");
+const parser_1 = require("./parser");
+function createTranscriptState() {
+    return {
+        nextTranscriptLookupAtMs: 0,
+        fileOffset: 0,
+        lineBuffer: "",
+        initialized: false,
+        seenTranscriptRecord: false,
+        activeTools: new Map(),
+        activeSubagentTools: new Map(),
+        waiting: false,
+        lastEventAtMs: 0,
+        busyUntilMs: 0,
+        lastActivityText: undefined,
+        lastActivityTool: undefined,
+        lastActivityPath: undefined
+    };
+}
+function resetTranscriptState(state) {
+    state.fileOffset = 0;
+    state.lineBuffer = "";
+    state.initialized = false;
+    state.seenTranscriptRecord = false;
+    state.waiting = false;
+    state.lastEventAtMs = 0;
+    state.busyUntilMs = 0;
+    state.lastActivityText = undefined;
+    state.lastActivityTool = undefined;
+    state.lastActivityPath = undefined;
+    state.activeTools.clear();
+    state.activeSubagentTools.clear();
+}
+function applyParsedTranscriptRecords(state, records) {
+    for (const parsedRecord of records) {
+        const nowMs = Date.now();
+        switch (parsedRecord.type) {
+            case "assistant": {
+                processAssistantRecord(state, parsedRecord.record, nowMs);
+                break;
+            }
+            case "user": {
+                processUserRecord(state, parsedRecord.record, nowMs);
+                break;
+            }
+            case "system": {
+                processSystemRecord(state, parsedRecord.record);
+                break;
+            }
+            case "progress": {
+                processProgressRecord(state, parsedRecord.record, nowMs);
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+        state.seenTranscriptRecord = true;
+        state.lastEventAtMs = nowMs;
+    }
+}
+function processAssistantRecord(state, record, nowMs) {
+    const message = (0, parser_1.readRecord)(record.message);
+    const content = (0, parser_1.readArray)(message?.content);
+    if (!content) {
+        return;
+    }
+    let hasToolUse = false;
+    let hasText = false;
+    for (const block of content) {
+        const parsedBlock = (0, parser_1.readRecord)(block);
+        if (!parsedBlock) {
+            continue;
+        }
+        const blockType = (0, parser_1.readString)(parsedBlock.type);
+        if (blockType === "tool_use") {
+            const toolId = (0, parser_1.readString)(parsedBlock.id);
+            if (!toolId) {
+                continue;
+            }
+            const toolName = (0, parser_1.readString)(parsedBlock.name) ?? "Tool";
+            const input = (0, parser_1.readRecord)(parsedBlock.input) ?? {};
+            const entry = createActiveToolEntry(toolName, input, nowMs);
+            state.activeTools.set(toolId, entry);
+            setLastActivity(state, entry.statusText, entry.activityTool, entry.activityPath);
+            hasToolUse = true;
+            continue;
+        }
+        if (blockType === "text") {
+            hasText = true;
+        }
+    }
+    if (hasToolUse) {
+        state.waiting = false;
+        state.busyUntilMs = nowMs + constants_1.textIdleDelayMs;
+        return;
+    }
+    if (hasText) {
+        state.waiting = false;
+        state.busyUntilMs = nowMs + constants_1.textIdleDelayMs;
+        if (!state.lastActivityText) {
+            setLastActivity(state, "Responding", "terminal", undefined);
+        }
+    }
+}
+function processUserRecord(state, record, nowMs) {
+    const message = (0, parser_1.readRecord)(record.message);
+    const content = message?.content;
+    if (Array.isArray(content)) {
+        let hasToolResult = false;
+        for (const block of content) {
+            const parsedBlock = (0, parser_1.readRecord)(block);
+            if (!parsedBlock || (0, parser_1.readString)(parsedBlock.type) !== "tool_result") {
+                continue;
+            }
+            const completedToolId = (0, parser_1.readString)(parsedBlock.tool_use_id);
+            if (!completedToolId) {
+                continue;
+            }
+            const completedToolName = state.activeTools.get(completedToolId)?.toolName;
+            if (normalizeToolName(completedToolName ?? "") === "task") {
+                state.activeSubagentTools.delete(completedToolId);
+            }
+            state.activeTools.delete(completedToolId);
+            hasToolResult = true;
+        }
+        if (hasToolResult) {
+            state.waiting = false;
+            state.busyUntilMs = nowMs + constants_1.textIdleDelayMs;
+            return;
+        }
+        const hasPromptText = content.some((block) => {
+            if (typeof block === "string") {
+                return block.trim().length > 0;
+            }
+            const parsedBlock = (0, parser_1.readRecord)(block);
+            if (!parsedBlock) {
+                return false;
+            }
+            if ((0, parser_1.readString)(parsedBlock.type) !== "text") {
+                return false;
+            }
+            const text = (0, parser_1.readString)(parsedBlock.text);
+            return Boolean(text && text.trim().length > 0);
+        });
+        if (hasPromptText) {
+            clearActiveTools(state);
+            state.waiting = false;
+            state.busyUntilMs = nowMs + constants_1.textIdleDelayMs;
+            setLastActivity(state, "Responding", "terminal", undefined);
+        }
+        return;
+    }
+    if (typeof content === "string" && content.trim().length > 0) {
+        clearActiveTools(state);
+        state.waiting = false;
+        state.busyUntilMs = nowMs + constants_1.textIdleDelayMs;
+        setLastActivity(state, "Responding", "terminal", undefined);
+    }
+}
+function processSystemRecord(state, record) {
+    if ((0, parser_1.readString)(record.subtype) !== "turn_duration") {
+        return;
+    }
+    clearActiveTools(state);
+    state.waiting = true;
+    state.busyUntilMs = 0;
+    state.lastActivityText = undefined;
+    state.lastActivityTool = undefined;
+    state.lastActivityPath = undefined;
+}
+function processProgressRecord(state, record, nowMs) {
+    const parentToolId = (0, parser_1.readString)(record.parentToolUseID) ?? (0, parser_1.readString)(record.parent_tool_use_id);
+    if (!parentToolId) {
+        return;
+    }
+    const data = (0, parser_1.readRecord)(record.data);
+    if (!data) {
+        return;
+    }
+    const progressType = (0, parser_1.readString)(data.type);
+    if ((progressType === "bash_progress" || progressType === "mcp_progress") && state.activeTools.has(parentToolId)) {
+        touchTool(state.activeTools.get(parentToolId), nowMs);
+        state.waiting = false;
+        state.busyUntilMs = nowMs + constants_1.textIdleDelayMs;
+        return;
+    }
+    const parentTool = state.activeTools.get(parentToolId);
+    if (!parentTool || normalizeToolName(parentTool.toolName) !== "task") {
+        return;
+    }
+    const progressMessage = (0, parser_1.readRecord)(data.message);
+    const messageType = (0, parser_1.readString)(progressMessage?.type);
+    const innerMessage = (0, parser_1.readRecord)(progressMessage?.message);
+    const content = (0, parser_1.readArray)(innerMessage?.content);
+    if (!messageType || !content) {
+        return;
+    }
+    if (messageType === "assistant") {
+        let subagentTools = state.activeSubagentTools.get(parentToolId);
+        if (!subagentTools) {
+            subagentTools = new Map();
+            state.activeSubagentTools.set(parentToolId, subagentTools);
+        }
+        for (const block of content) {
+            const parsedBlock = (0, parser_1.readRecord)(block);
+            if (!parsedBlock || (0, parser_1.readString)(parsedBlock.type) !== "tool_use") {
+                continue;
+            }
+            const toolId = (0, parser_1.readString)(parsedBlock.id);
+            if (!toolId) {
+                continue;
+            }
+            const toolName = (0, parser_1.readString)(parsedBlock.name) ?? "Tool";
+            const input = (0, parser_1.readRecord)(parsedBlock.input) ?? {};
+            const entry = createActiveToolEntry(toolName, input, nowMs);
+            subagentTools.set(toolId, entry);
+            setLastActivity(state, entry.statusText, entry.activityTool, entry.activityPath);
+        }
+        state.waiting = false;
+        state.busyUntilMs = nowMs + constants_1.textIdleDelayMs;
+        return;
+    }
+    if (messageType === "user") {
+        const subagentTools = state.activeSubagentTools.get(parentToolId);
+        if (!subagentTools) {
+            return;
+        }
+        for (const block of content) {
+            const parsedBlock = (0, parser_1.readRecord)(block);
+            if (!parsedBlock || (0, parser_1.readString)(parsedBlock.type) !== "tool_result") {
+                continue;
+            }
+            const completedToolId = (0, parser_1.readString)(parsedBlock.tool_use_id);
+            if (!completedToolId) {
+                continue;
+            }
+            subagentTools.delete(completedToolId);
+        }
+        if (subagentTools.size === 0) {
+            state.activeSubagentTools.delete(parentToolId);
+        }
+        state.waiting = false;
+        state.busyUntilMs = nowMs + constants_1.textIdleDelayMs;
+    }
+}
+function createActiveToolEntry(toolName, input, nowMs) {
+    const normalizedTool = normalizeToolName(toolName);
+    const activityPath = extractPathFromInput(input);
+    return {
+        toolName,
+        statusText: formatToolStatus(normalizedTool, toolName, input, activityPath),
+        activityTool: mapActivityTool(normalizedTool),
+        activityPath,
+        lastProgressAtMs: nowMs
+    };
+}
+function formatToolStatus(normalizedToolName, rawToolName, input, activityPath) {
+    switch (normalizedToolName) {
+        case "read":
+            return activityPath ? `Reading ${node_path_1.default.basename(activityPath)}` : "Reading";
+        case "edit":
+            return activityPath ? `Editing ${node_path_1.default.basename(activityPath)}` : "Editing";
+        case "write":
+            return activityPath ? `Writing ${node_path_1.default.basename(activityPath)}` : "Writing";
+        case "bash": {
+            const command = extractCommandText(input);
+            if (!command) {
+                return "Running command";
+            }
+            return `Running: ${truncate(command, constants_1.bashCommandDisplayMaxLength)}`;
+        }
+        case "glob":
+        case "grep":
+            return "Searching code";
+        case "task": {
+            const description = typeof input.description === "string" ? input.description.trim() : "";
+            return description ? `Subtask: ${truncate(description, constants_1.taskDescriptionDisplayMaxLength)}` : "Running subtask";
+        }
+        case "askuserquestion":
+            return "Waiting for your answer";
+        case "todowrite":
+            return "Planning";
+        case "webfetch":
+        case "websearch":
+            return "Fetching web content";
+        case "enterplanmode":
+            return "Planning";
+        default:
+            return `Using ${rawToolName}`;
+    }
+}
+function mapActivityTool(normalizedToolName) {
+    switch (normalizedToolName) {
+        case "read":
+            return "read";
+        case "edit":
+            return "edit";
+        case "write":
+            return "write";
+        case "bash":
+            return "bash";
+        case "grep":
+            return "grep";
+        case "glob":
+            return "glob";
+        case "task":
+            return "task";
+        case "todowrite":
+            return "todo";
+        case "webfetch":
+        case "websearch":
+            return "web";
+        case "askuserquestion":
+            return "terminal";
+        default:
+            return "unknown";
+    }
+}
+function extractPathFromInput(input) {
+    const keys = ["file_path", "filePath", "path", "target_path", "targetPath"];
+    for (const key of keys) {
+        const value = input[key];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function extractCommandText(input) {
+    const command = input.command;
+    if (typeof command === "string") {
+        return command.trim() || undefined;
+    }
+    if (Array.isArray(command)) {
+        const parts = command.filter((part) => typeof part === "string");
+        const joined = parts.join(" ").trim();
+        return joined || undefined;
+    }
+    return undefined;
+}
+function setLastActivity(state, text, tool, activityPath) {
+    state.lastActivityText = text;
+    state.lastActivityTool = tool;
+    state.lastActivityPath = activityPath;
+}
+function touchTool(tool, nowMs) {
+    if (!tool) {
+        return;
+    }
+    tool.lastProgressAtMs = nowMs;
+}
+function clearActiveTools(state) {
+    state.activeTools.clear();
+    state.activeSubagentTools.clear();
+}
+function normalizeToolName(toolName) {
+    return toolName.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+}
+function truncate(value, maxLength) {
+    return value.length > maxLength ? `${value.slice(0, maxLength)}...` : value;
+}

package/dist/server/server/status/claudeTranscript/constants.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.permissionExemptTools = exports.taskDescriptionDisplayMaxLength = exports.bashCommandDisplayMaxLength = exports.transcriptLookupRetryMs = exports.maxRecentTranscriptAgeMs = exports.activeToolStaleAfterMs = exports.permissionIdleDelayMs = exports.textIdleDelayMs = exports.bootstrapTailBytes = exports.claudeProjectRoot = void 0;
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.claudeProjectRoot = node_path_1.default.join(node_os_1.default.homedir(), ".claude", "projects");
+exports.bootstrapTailBytes = 196_608;
+exports.textIdleDelayMs = 5_000;
+exports.permissionIdleDelayMs = 12_000;
+exports.activeToolStaleAfterMs = 45_000;
+exports.maxRecentTranscriptAgeMs = 3 * 24 * 60 * 60 * 1000;
+exports.transcriptLookupRetryMs = 2_000;
+exports.bashCommandDisplayMaxLength = 72;
+exports.taskDescriptionDisplayMaxLength = 56;
+exports.permissionExemptTools = new Set(["task", "askuserquestion"]);