@openlucaskaka/kagent 0.1.7

package/npm/lib/app-state.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAppRuntimeState = createAppRuntimeState;
+exports.appRuntimeReducer = appRuntimeReducer;
+const provider_setup_1 = require("./provider-setup");
+const transcript_1 = require("./transcript");
+function createAppRuntimeState() {
+    return {
+        transcript: (0, transcript_1.createTranscriptState)(),
+        status: "starting",
+        statusText: "",
+        approval: null,
+        provider: null,
+        setup: null,
+        commandCatalog: [],
+    };
+}
+function appRuntimeReducer(state, action) {
+    if (action.type === "submit") {
+        return {
+            ...state,
+            transcript: (0, transcript_1.transcriptReducer)(state.transcript, {
+                type: "user_submitted",
+                text: action.text,
+            }),
+            status: "thinking",
+            statusText: action.command ? "Running command" : "Thinking",
+        };
+    }
+    if (action.type === "setup_action") {
+        return state.setup
+            ? { ...state, setup: (0, provider_setup_1.providerSetupReducer)(state.setup, action.action) }
+            : state;
+    }
+    if (action.type === "approval_response") {
+        return {
+            ...state,
+            approval: null,
+            status: "thinking",
+            statusText: action.approved ? "Continuing" : "Cancelling",
+        };
+    }
+    if (action.type === "cancel_requested") {
+        return { ...state, status: "cancelling", statusText: action.label };
+    }
+    if (action.type === "transcript_action") {
+        return {
+            ...state,
+            transcript: (0, transcript_1.transcriptReducer)(state.transcript, action.action),
+        };
+    }
+    if (action.type === "error") {
+        return failureState(state, action.message);
+    }
+    return reduceRuntimeEvent(state, action.channel, action.event);
+}
+function reduceRuntimeEvent(state, channel, event) {
+    if (channel === "lifecycle") {
+        return reduceLifecycleEvent(state, event);
+    }
+    if (channel === "provider") {
+        return reduceProviderEvent(state, event);
+    }
+    if (channel === "command") {
+        return reduceCommandEvent(state, event);
+    }
+    return reduceRunEvent(state, event);
+}
+function reduceLifecycleEvent(state, event) {
+    if (event.type === "runtime_ready") {
+        try {
+            return {
+                ...state,
+                provider: event.provider,
+                commandCatalog: event.session_commands || [],
+                setup: event.provider.configured
+                    ? null
+                    : (0, provider_setup_1.createProviderSetupState)(event.provider_options),
+                status: "idle",
+                statusText: "",
+            };
+        }
+        catch (error) {
+            return failureState(state, errorMessage(error));
+        }
+    }
+    if (event.type === "runtime_unavailable" || event.type === "client_failed") {
+        return failureState(state, event.message);
+    }
+    return state;
+}
+function reduceProviderEvent(state, event) {
+    if (event.type === "provider_configured") {
+        return {
+            ...state,
+            provider: event.provider,
+            setup: null,
+            status: "idle",
+            statusText: "",
+        };
+    }
+    if (event.type === "provider_configuration_failed" || event.type === "client_failed") {
+        if (!state.setup) {
+            return failureState(state, event.message);
+        }
+        return {
+            ...state,
+            setup: (0, provider_setup_1.providerSetupReducer)(state.setup, {
+                type: "failure",
+                message: event.message,
+                field: event.type === "provider_configuration_failed" ? event.field : undefined,
+            }),
+        };
+    }
+    return state;
+}
+function reduceCommandEvent(state, event) {
+    if (event.type === "session_command_completed") {
+        return {
+            ...state,
+            status: "idle",
+            statusText: "",
+            transcript: (0, transcript_1.transcriptReducer)(state.transcript, {
+                type: "command_completed",
+                title: event.title,
+                text: event.message,
+                clear: event.clear_messages,
+            }),
+        };
+    }
+    if (event.type === "session_command_failed" || event.type === "client_failed") {
+        return failureState(state, event.message);
+    }
+    return state;
+}
+function reduceRunEvent(state, event) {
+    if (event.type === "run_started") {
+        return { ...state, status: "thinking", statusText: "Thinking" };
+    }
+    if (event.type === "run_progress") {
+        const transcriptAction = (0, transcript_1.progressTranscriptAction)(event.event);
+        return {
+            ...state,
+            statusText: progressLabel(event.event),
+            transcript: transcriptAction
+                ? (0, transcript_1.transcriptReducer)(state.transcript, transcriptAction)
+                : state.transcript,
+        };
+    }
+    if (event.type === "run_cancel_requested") {
+        return { ...state, status: "cancelling", statusText: "Stopping" };
+    }
+    if (event.type === "run_steer_queued") {
+        return {
+            ...state,
+            status: "thinking",
+            statusText: event.replaced === "true" ? "Instruction updated" : "Instruction queued",
+        };
+    }
+    if (event.type === "run_steer_rejected") {
+        return {
+            ...state,
+            statusText: "Instruction was not applied",
+        };
+    }
+    if (event.type === "approval_required") {
+        return { ...state, approval: event, status: "approval", statusText: "" };
+    }
+    if (event.type === "run_completed") {
+        const fallback = event.status === "cancelled" ? "Action cancelled." : "Done.";
+        return {
+            ...state,
+            approval: null,
+            status: "idle",
+            statusText: "",
+            transcript: (0, transcript_1.transcriptReducer)(state.transcript, {
+                type: "assistant_completed",
+                text: event.answer || fallback,
+                outcome: event.status === "cancelled" ? "cancelled" : "complete",
+            }),
+        };
+    }
+    if (event.type === "run_failed") {
+        const message = event.error_code === "approval_execution_interrupted"
+            ? "Action outcome is uncertain. kagent did not retry it. Check the target before trying again."
+            : event.message;
+        return failureState({ ...state, approval: null }, message);
+    }
+    if (event.type === "client_failed") {
+        return failureState({ ...state, approval: null }, event.message);
+    }
+    return state;
+}
+function failureState(state, message) {
+    return {
+        ...state,
+        approval: null,
+        status: "error",
+        statusText: "",
+        transcript: (0, transcript_1.transcriptReducer)(state.transcript, { type: "error", text: message }),
+    };
+}
+function progressLabel(event) {
+    const type = String(event.type || "");
+    if (type === "steering_applied") {
+        return "Updating direction";
+    }
+    if (type === "planner_started") {
+        return "Thinking";
+    }
+    if (type === "plan_ready") {
+        return "Planning next steps";
+    }
+    if (type === "tool_started") {
+        return "Working";
+    }
+    if (type === "tool_completed") {
+        return "Reviewing result";
+    }
+    return type.endsWith("failed") ? "Retrying" : "Working";
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/npm/lib/approval-choice.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveApprovalInput = resolveApprovalInput;
+function resolveApprovalInput(choice, value, keyName = "") {
+    const answer = value.toLowerCase();
+    if (answer === "d") {
+        return { type: "toggle_details" };
+    }
+    if (answer === "y") {
+        return { type: "submit", approved: true };
+    }
+    if (answer === "n") {
+        return { type: "submit", approved: false };
+    }
+    if (keyName === "left" || keyName === "up") {
+        return { type: "select", choice: "allow" };
+    }
+    if (keyName === "right" || keyName === "down") {
+        return { type: "select", choice: "deny" };
+    }
+    if (keyName === "enter" || keyName === "return") {
+        return { type: "submit", approved: choice === "allow" };
+    }
+    return null;
+}

package/npm/lib/commands.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateCommandMenu = updateCommandMenu;
+exports.moveCommandSelection = moveCommandSelection;
+exports.commandCompletion = commandCompletion;
+function updateCommandMenu(catalog, input, previous) {
+    const query = commandQuery(input);
+    if (query === null) {
+        return null;
+    }
+    const normalized = query.toLowerCase();
+    const options = catalog.filter((option) => commandNames(option).some((name) => name.toLowerCase().startsWith(normalized)));
+    if (options.length === 0) {
+        return null;
+    }
+    const selectedCommand = typeof previous === "string" ? previous : previous?.selectedCommand;
+    const previousIndex = selectedCommand
+        ? options.findIndex((option) => option.command === selectedCommand)
+        : -1;
+    const selectedIndex = previousIndex >= 0 ? previousIndex : 0;
+    return {
+        query,
+        options,
+        selectedIndex,
+        selectedCommand: options[selectedIndex].command,
+    };
+}
+function moveCommandSelection(state, offset) {
+    if (offset === 0 || state.options.length === 0) {
+        return state;
+    }
+    const selectedIndex = wrapIndex(state.selectedIndex + offset, state.options.length);
+    return {
+        ...state,
+        selectedIndex,
+        selectedCommand: state.options[selectedIndex].command,
+    };
+}
+function commandCompletion(state) {
+    const selected = state.options[state.selectedIndex];
+    if (!selected) {
+        return state.query;
+    }
+    const commandName = selected.command.split(/\s+/, 1)[0];
+    return selected.command.includes(" ") ? `${commandName} ` : commandName;
+}
+function commandQuery(input) {
+    const value = input.trimStart();
+    if (!value.startsWith("/") || /\s/.test(value)) {
+        return null;
+    }
+    return value;
+}
+function commandNames(option) {
+    return [option.command.split(/\s+/, 1)[0], ...option.aliases];
+}
+function wrapIndex(value, length) {
+    return ((value % length) + length) % length;
+}

package/npm/lib/editor.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitGraphemes = void 0;
+exports.createEditorState = createEditorState;
+exports.insertInput = insertInput;
+exports.deleteBeforeCursor = deleteBeforeCursor;
+exports.deleteAtCursor = deleteAtCursor;
+exports.moveCursor = moveCursor;
+exports.moveCursorVertical = moveCursorVertical;
+exports.editorVisualLineCount = editorVisualLineCount;
+exports.moveCursorToStart = moveCursorToStart;
+exports.moveCursorToEnd = moveCursorToEnd;
+exports.submitInput = submitInput;
+exports.navigateHistory = navigateHistory;
+const terminal_text_1 = require("./terminal-text");
+var terminal_text_2 = require("./terminal-text");
+Object.defineProperty(exports, "splitGraphemes", { enumerable: true, get: function () { return terminal_text_2.splitGraphemes; } });
+function createEditorState(history = []) {
+    return {
+        value: "",
+        cursor: 0,
+        history: history.slice(),
+        historyIndex: null,
+        draft: "",
+    };
+}
+function insertInput(state, rawInput) {
+    const characters = (0, terminal_text_1.splitGraphemes)(state.value);
+    const cursor = clampCursor(state.cursor, characters.length);
+    const before = characters.slice(0, cursor).join("");
+    const inserted = (0, terminal_text_1.splitGraphemes)(rawInput).filter(isPrintableGrapheme).join("");
+    const after = characters.slice(cursor).join("");
+    const prefix = before + inserted;
+    return editBuffer(state, prefix + after, (0, terminal_text_1.splitGraphemes)(prefix).length);
+}
+function deleteBeforeCursor(state) {
+    const characters = (0, terminal_text_1.splitGraphemes)(state.value);
+    const cursor = clampCursor(state.cursor, characters.length);
+    if (cursor === 0) {
+        return state;
+    }
+    characters.splice(cursor - 1, 1);
+    return editBuffer(state, characters.join(""), cursor - 1);
+}
+function deleteAtCursor(state) {
+    const characters = (0, terminal_text_1.splitGraphemes)(state.value);
+    const cursor = clampCursor(state.cursor, characters.length);
+    if (cursor === characters.length) {
+        return state;
+    }
+    characters.splice(cursor, 1);
+    return editBuffer(state, characters.join(""), cursor);
+}
+function moveCursor(state, offset) {
+    const length = (0, terminal_text_1.splitGraphemes)(state.value).length;
+    return {
+        ...state,
+        cursor: clampCursor(state.cursor + offset, length),
+    };
+}
+function moveCursorVertical(state, direction, columns = Number.MAX_SAFE_INTEGER) {
+    const characters = (0, terminal_text_1.splitGraphemes)(state.value);
+    const cursor = clampCursor(state.cursor, characters.length);
+    const positions = visualCursorPositions(characters, columns);
+    const current = positions[cursor];
+    const targetRow = current.row + direction;
+    if (targetRow < 0 || targetRow >= positions.at(-1).row + 1) {
+        return state;
+    }
+    let targetCursor = cursor;
+    let targetDistance = Number.MAX_SAFE_INTEGER;
+    positions.forEach((position, index) => {
+        if (position.row !== targetRow) {
+            return;
+        }
+        const distance = Math.abs(position.column - current.column);
+        if (distance < targetDistance) {
+            targetCursor = index;
+            targetDistance = distance;
+        }
+    });
+    return {
+        ...state,
+        cursor: targetCursor,
+    };
+}
+function editorVisualLineCount(value, columns) {
+    const positions = visualCursorPositions((0, terminal_text_1.splitGraphemes)(value), columns);
+    const finalPosition = positions.at(-1);
+    return finalPosition.row + 1;
+}
+function moveCursorToStart(state) {
+    return { ...state, cursor: 0 };
+}
+function moveCursorToEnd(state) {
+    return { ...state, cursor: (0, terminal_text_1.splitGraphemes)(state.value).length };
+}
+function submitInput(state) {
+    const value = state.value.trim();
+    if (!value) {
+        return { value: null, state };
+    }
+    return {
+        value,
+        state: createEditorState(state.history.concat(value)),
+    };
+}
+function navigateHistory(state, offset) {
+    if (state.history.length === 0 || offset === 0) {
+        return state;
+    }
+    if (offset < 0) {
+        const historyIndex = state.historyIndex === null
+            ? state.history.length - 1
+            : Math.max(state.historyIndex - 1, 0);
+        return historyState(state, historyIndex, state.historyIndex === null ? state.value : state.draft);
+    }
+    if (state.historyIndex === null) {
+        return state;
+    }
+    if (state.historyIndex < state.history.length - 1) {
+        return historyState(state, state.historyIndex + 1, state.draft);
+    }
+    return {
+        ...state,
+        value: state.draft,
+        cursor: (0, terminal_text_1.splitGraphemes)(state.draft).length,
+        historyIndex: null,
+        draft: "",
+    };
+}
+function historyState(state, historyIndex, draft) {
+    const value = state.history[historyIndex];
+    return {
+        ...state,
+        value,
+        cursor: (0, terminal_text_1.splitGraphemes)(value).length,
+        historyIndex,
+        draft,
+    };
+}
+function editBuffer(state, value, cursor) {
+    return {
+        ...state,
+        value,
+        cursor,
+        ...(isEditorState(state) ? { historyIndex: null, draft: "" } : {}),
+    };
+}
+function isEditorState(state) {
+    return "history" in state;
+}
+function clampCursor(cursor, length) {
+    return Math.min(Math.max(cursor, 0), length);
+}
+function visualCursorPositions(characters, columns) {
+    const safeColumns = Math.max(1, Math.trunc(columns));
+    const positions = [{ row: 0, column: 0 }];
+    let row = 0;
+    let column = 0;
+    characters.forEach((character) => {
+        if (character === "\n") {
+            row += 1;
+            column = 0;
+        }
+        else {
+            const width = (0, terminal_text_1.terminalGraphemeWidth)(character);
+            if (column > 0 && column + width > safeColumns) {
+                row += 1;
+                column = 0;
+            }
+            column += width;
+            if (column >= safeColumns) {
+                row += 1;
+                column = 0;
+            }
+        }
+        positions.push({ row, column });
+    });
+    return positions;
+}
+function isPrintableGrapheme(character) {
+    if (character === "\n") {
+        return true;
+    }
+    const codePoint = character.codePointAt(0) || 0;
+    return codePoint >= 32 && codePoint !== 127;
+}

package/npm/lib/ink-runner.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldRunInkTui = shouldRunInkTui;
+exports.runKagentInk = runKagentInk;
+const App_1 = require("./App");
+const dynamicImport = new Function("specifier", "return import(specifier)");
+function shouldRunInkTui(args, stdin) {
+    if (process.env.KAGENT_CLASSIC_UI) {
+        return false;
+    }
+    if (args.includes("--classic")) {
+        return false;
+    }
+    if (args.length > 0) {
+        return false;
+    }
+    return Boolean(stdin && stdin.isTTY);
+}
+async function runKagentInk(_args, options = {}) {
+    try {
+        const React = (await dynamicImport("react"));
+        const Ink = (await dynamicImport("ink"));
+        const element = React.createElement(App_1.KagentInkApp, { React, Ink: Ink });
+        Ink.render(element, { exitOnCtrlC: false });
+    }
+    catch (error) {
+        if (typeof options.fallback === "function") {
+            process.stderr.write(`kagent: terminal UI unavailable: ${errorMessage(error)}; using classic CLI\n`);
+            options.fallback();
+            return;
+        }
+        throw error;
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+module.exports = {
+    runKagentInk,
+    shouldRunInkTui,
+};

package/npm/lib/kagent-home.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveKagentHome = resolveKagentHome;
+exports.kagentStatePath = kagentStatePath;
+exports.kagentCachePath = kagentCachePath;
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+function requiredHome(env) {
+    const home = env.HOME?.trim();
+    return home || node_os_1.default.homedir();
+}
+function resolveKagentHome(env = process.env) {
+    const configured = env.KAGENT_HOME;
+    if (Object.prototype.hasOwnProperty.call(env, "KAGENT_HOME")) {
+        if (!configured?.trim()) {
+            throw new Error("KAGENT_HOME must not be empty");
+        }
+        if (configured === "~") {
+            return node_path_1.default.resolve(requiredHome(env));
+        }
+        if (configured.startsWith("~/")) {
+            return node_path_1.default.resolve(requiredHome(env), configured.slice(2));
+        }
+        if (!node_path_1.default.isAbsolute(configured)) {
+            throw new Error("KAGENT_HOME must be an absolute or tilde-prefixed path");
+        }
+        return node_path_1.default.resolve(configured);
+    }
+    return node_path_1.default.resolve(requiredHome(env), ".kagent");
+}
+function kagentStatePath(name, env = process.env) {
+    return node_path_1.default.join(resolveKagentHome(env), "state", name);
+}
+function kagentCachePath(name, env = process.env) {
+    return node_path_1.default.join(resolveKagentHome(env), "cache", name);
+}