@kilocode/cli
Version:
Terminal User Interface for Kilo Code
1,428 lines (1,413 loc) • 2.46 MB
JavaScript
#!/usr/bin/env node
import { createRequire as __createRequire__ } from 'module';
import { fileURLToPath as __fileURLToPath__ } from 'url';
import { dirname as __dirname__ } from 'path';
const require = __createRequire__(import.meta.url);
const __filename = __fileURLToPath__(import.meta.url);
const __dirname = __dirname__(__filename);
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
if (typeof require !== "undefined") return require.apply(this, arguments);
throw Error('Dynamic require of "' + x + '" is not supported');
});
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from2, except, desc) => {
if (from2 && typeof from2 === "object" || typeof from2 === "function") {
for (let key of __getOwnPropNames(from2))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
// src/utils/paths.ts
import * as crypto from "crypto";
import * as path from "path";
import * as fs from "fs";
var KiloCodePaths;
var init_paths = __esm({
"src/utils/paths.ts"() {
"use strict";
KiloCodePaths = class {
static BASE_DIR_NAME = ".kilocode";
static CLI_SUBDIR = "cli";
static WORKSPACE_MAP_FILE = "workspace-map.json";
/**
* Get user home directory
*/
static getHomeDir() {
return process.env.HOME || process.env.USERPROFILE || "/tmp";
}
/**
* Get base .kilocode/cli directory in user home
*/
static getKiloCodeDir() {
return path.join(this.getHomeDir(), this.BASE_DIR_NAME, this.CLI_SUBDIR);
}
/**
* Get unified logs directory (shared across all workspaces)
*/
static getLogsDir() {
return path.join(this.getKiloCodeDir(), "logs");
}
/**
* Get global storage directory (shared across all workspaces)
*/
static getGlobalStorageDir() {
return path.join(this.getKiloCodeDir(), "global");
}
/**
* Get workspaces base directory
*/
static getWorkspacesDir() {
return path.join(this.getKiloCodeDir(), "workspaces");
}
/**
* Generate a deterministic 8-character hash for a workspace path
*/
static getWorkspaceHash(workspacePath) {
const absolutePath = path.resolve(workspacePath);
const hash = crypto.createHash("sha256").update(absolutePath).digest("hex");
return hash.substring(0, 8);
}
/**
* Sanitize workspace name for filesystem use
* - Convert to lowercase
* - Replace spaces and special chars with hyphens
* - Remove consecutive hyphens
* - Limit to 32 characters
*/
static sanitizeWorkspaceName(workspacePath) {
const basename4 = path.basename(workspacePath);
let sanitized = basename4.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
if (sanitized.length > 32) {
sanitized = sanitized.substring(0, 32);
}
if (!sanitized) {
sanitized = "workspace";
}
return sanitized;
}
/**
* Get workspace folder name in format: {sanitized-name}-{hash}
*/
static getWorkspaceFolderName(workspacePath) {
const sanitizedName = this.sanitizeWorkspaceName(workspacePath);
const hash = this.getWorkspaceHash(workspacePath);
return `${sanitizedName}-${hash}`;
}
/**
* Get workspace storage directory for a specific workspace
*/
static getWorkspaceStorageDir(workspacePath) {
const folderName = this.getWorkspaceFolderName(workspacePath);
return path.join(this.getWorkspacesDir(), folderName);
}
/**
* Ensure a directory exists, creating it if necessary
*/
static ensureDirectoryExists(dirPath) {
try {
if (!fs.existsSync(dirPath)) {
fs.mkdirSync(dirPath, { recursive: true });
}
} catch {
}
}
/**
* Get the workspace map file path
*/
static getWorkspaceMapPath() {
return path.join(this.getWorkspacesDir(), this.WORKSPACE_MAP_FILE);
}
/**
* Load workspace map (maps absolute paths to folder names)
*/
static getWorkspaceMap() {
try {
const mapPath = this.getWorkspaceMapPath();
if (fs.existsSync(mapPath)) {
const content = fs.readFileSync(mapPath, "utf-8");
return JSON.parse(content);
}
} catch {
}
return {};
}
/**
* Update workspace map with a new workspace entry
*/
static updateWorkspaceMap(workspacePath, folderName) {
try {
const absolutePath = path.resolve(workspacePath);
const map = this.getWorkspaceMap();
map[absolutePath] = folderName;
this.ensureDirectoryExists(this.getWorkspacesDir());
const mapPath = this.getWorkspaceMapPath();
fs.writeFileSync(mapPath, JSON.stringify(map, null, 2));
} catch {
}
}
/**
* Initialize all required directories for a workspace
*/
static initializeWorkspace(workspacePath) {
this.ensureDirectoryExists(this.getKiloCodeDir());
this.ensureDirectoryExists(this.getLogsDir());
this.ensureDirectoryExists(this.getGlobalStorageDir());
this.ensureDirectoryExists(this.getWorkspacesDir());
const workspaceDir = this.getWorkspaceStorageDir(workspacePath);
this.ensureDirectoryExists(workspaceDir);
const folderName = this.getWorkspaceFolderName(workspacePath);
this.updateWorkspaceMap(workspacePath, folderName);
}
};
}
});
// src/services/logs.ts
import { appendFileSync } from "fs";
import * as fs2 from "fs-extra";
import * as path2 from "path";
var LogsService, logs;
var init_logs = __esm({
"src/services/logs.ts"() {
"use strict";
init_paths();
LogsService = class _LogsService {
static instance = null;
logs = [];
maxEntries = 1e3;
listeners = [];
originalConsole = null;
logFilePath;
fileLoggingEnabled = true;
constructor() {
this.originalConsole = {
log: console.log,
error: console.error,
warn: console.warn,
debug: console.debug,
info: console.info
};
this.logFilePath = path2.join(KiloCodePaths.getLogsDir(), "cli.txt");
this.initializeFileLogging().catch(() => {
});
}
/**
* Get the singleton instance of LogsService
*/
static getInstance() {
if (!_LogsService.instance) {
_LogsService.instance = new _LogsService();
}
return _LogsService.instance;
}
/**
* Serialize an error object to a plain object with all relevant properties
*/
serializeError(error) {
if (error instanceof Error) {
return {
message: error.message,
name: error.name,
stack: error.stack,
// Include any additional enumerable properties
...Object.getOwnPropertyNames(error).filter((key) => key !== "message" && key !== "name" && key !== "stack").reduce(
(acc, key) => {
acc[key] = error[key];
return acc;
},
{}
)
};
}
return error;
}
/**
* Serialize context object, handling Error objects specially
*/
serializeContext(context) {
if (!context) {
return void 0;
}
const serialized = {};
for (const [key, value] of Object.entries(context)) {
if (value instanceof Error) {
serialized[key] = this.serializeError(value);
} else if (typeof value === "object" && value !== null) {
serialized[key] = this.serializeContext(value) || value;
} else {
serialized[key] = value;
}
}
return serialized;
}
/**
* Add a log entry with the specified level
*/
addLog(level, message, source, context) {
const serializedContext = this.serializeContext(context);
const entry = {
id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
ts: Date.now(),
level,
message,
...source && { source },
...serializedContext && { context: serializedContext }
};
this.logs.unshift(entry);
if (this.logs.length > this.maxEntries) {
this.logs = this.logs.slice(0, this.maxEntries);
}
this.listeners.forEach((listener) => listener(entry));
this.writeToFile(entry).catch(() => {
});
}
/**
* Output log entry to console with appropriate formatting
* Uses original console methods to avoid circular dependency
*/
outputToConsole(entry) {
if (this._isLogging) {
return;
}
if (!this.originalConsole) {
return;
}
;
this._isLogging = true;
try {
const ts = new Date(entry.ts).toISOString();
const source = entry.source ? `[${entry.source}]` : "";
const prefix = `${ts} ${source}`;
const isOriginalConsole = this.originalConsole.error.toString().includes("[native code]");
if (!isOriginalConsole) {
return;
}
switch (entry.level) {
case "error":
this.originalConsole.error(`${prefix} ERROR:`, entry.message, entry.context || "");
break;
case "warn":
this.originalConsole.warn(`${prefix} WARN:`, entry.message, entry.context || "");
break;
case "debug":
this.originalConsole.debug(`${prefix} DEBUG:`, entry.message, entry.context || "");
break;
case "info":
default:
this.originalConsole.log(`${prefix} INFO:`, entry.message, entry.context || "");
break;
}
} finally {
;
this._isLogging = false;
}
}
/**
* Initialize file logging by ensuring the log directory exists
*/
async initializeFileLogging() {
try {
const logDir = path2.dirname(this.logFilePath);
await fs2.ensureDir(logDir);
} catch (error) {
this.fileLoggingEnabled = false;
if (this.originalConsole) {
this.originalConsole.error("Failed to initialize file logging:", error);
}
}
}
/**
* Format log entry for file output (same format as outputToConsole)
*/
formatLogEntryForFile(entry) {
const ts = new Date(entry.ts).toISOString();
const source = entry.source ? `[${entry.source}]` : "";
const prefix = `${ts} ${source}`;
const contextStr = entry.context ? ` ${JSON.stringify(entry.context)}` : "";
switch (entry.level) {
case "error":
return `${prefix} ERROR: ${entry.message}${contextStr}`;
case "warn":
return `${prefix} WARN: ${entry.message}${contextStr}`;
case "debug":
return `${prefix} DEBUG: ${entry.message}${contextStr}`;
case "info":
default:
return `${prefix} INFO: ${entry.message}${contextStr}`;
}
}
/**
* Write log entry to file asynchronously
*/
async writeToFile(entry) {
if (!this.fileLoggingEnabled) {
return;
}
try {
const logDir = path2.dirname(this.logFilePath);
fs2.ensureDirSync(logDir);
const logLine = this.formatLogEntryForFile(entry) + "\n";
appendFileSync(this.logFilePath, logLine, "utf8");
} catch (error) {
this.fileLoggingEnabled = false;
if (this.originalConsole) {
this.originalConsole.error("Failed to write to log file:", error);
}
}
}
/**
* Log an info message
*/
info(message, source, context) {
this.addLog("info", message, source, context);
}
/**
* Log a debug message
*/
debug(message, source, context) {
this.addLog("debug", message, source, context);
}
/**
* Log an error message
*/
error(message, source, context) {
this.addLog("error", message, source, context);
}
/**
* Log a warning message
*/
warn(message, source, context) {
this.addLog("warn", message, source, context);
}
/**
* Get all logs with optional filtering
*/
getLogs(filter2) {
let filteredLogs = [...this.logs];
if (filter2) {
if (filter2.levels && filter2.levels.length > 0) {
filteredLogs = filteredLogs.filter((log) => filter2.levels.includes(log.level));
}
if (filter2.source) {
filteredLogs = filteredLogs.filter((log) => log.source?.includes(filter2.source));
}
if (filter2.since) {
filteredLogs = filteredLogs.filter((log) => log.ts >= filter2.since);
}
}
return filteredLogs;
}
/**
* Get logs count by level
*/
getLogCounts() {
const counts = {
info: 0,
debug: 0,
error: 0,
warn: 0
};
this.logs.forEach((log) => {
counts[log.level]++;
});
return counts;
}
/**
* Subscribe to new log entries
*/
subscribe(listener) {
this.listeners.push(listener);
return () => {
const index = this.listeners.indexOf(listener);
if (index > -1) {
this.listeners.splice(index, 1);
}
};
}
/**
* Clear all logs
*/
clear() {
this.logs = [];
}
/**
* Set maximum number of log entries to keep
*/
setMaxEntries(max) {
this.maxEntries = max;
if (this.logs.length > max) {
this.logs = this.logs.slice(0, max);
}
}
/**
* Get current configuration
*/
getConfig() {
return {
maxEntries: this.maxEntries,
totalLogs: this.logs.length,
fileLoggingEnabled: this.fileLoggingEnabled,
logFilePath: this.logFilePath
};
}
/**
* Get the log file path
*/
getLogFilePath() {
return this.logFilePath;
}
/**
* Check if file logging is enabled
*/
isFileLoggingEnabled() {
return this.fileLoggingEnabled;
}
};
logs = LogsService.getInstance();
}
});
// src/services/telemetry/events.ts
var init_events = __esm({
"src/services/telemetry/events.ts"() {
"use strict";
}
});
// ../packages/types/src/api.ts
var init_api = __esm({
"../packages/types/src/api.ts"() {
"use strict";
}
});
// ../packages/types/src/kilocode/kilocode.ts
import { z } from "zod";
function getKiloBaseUriFromToken(kilocodeToken) {
if (kilocodeToken) {
try {
const payload_string = kilocodeToken.split(".")[1];
if (!payload_string) return "https://api.kilocode.ai";
const payload_json = typeof atob !== "undefined" ? atob(payload_string) : Buffer.from(payload_string, "base64").toString();
const payload = JSON.parse(payload_json);
if (payload.env === "development") return "http://localhost:3000";
} catch (_error) {
console.warn("Failed to get base URL from Kilo Code token");
}
}
return "https://api.kilocode.ai";
}
function getKiloUrlFromToken(targetUrl, kilocodeToken) {
const baseUrl = getKiloBaseUriFromToken(kilocodeToken);
const target = new URL(targetUrl);
const { protocol, host } = new URL(baseUrl);
Object.assign(target, { protocol, host });
return target.toString();
}
function getGlobalKilocodeBackendUrl() {
return (typeof window !== "undefined" ? window.KILOCODE_BACKEND_BASE_URL : void 0) || process.env.KILOCODE_BACKEND_BASE_URL || DEFAULT_KILOCODE_BACKEND_URL;
}
function removeTrailingSlash(url, pathname) {
return url.endsWith("/") && (pathname === "/" || pathname === "") ? url.slice(0, -1) : url;
}
function ensureLeadingSlash(path12) {
return path12.startsWith("/") ? path12 : `/${path12}`;
}
function buildUrl(path12 = "") {
try {
const backend = new URL(getGlobalKilocodeBackendUrl());
const result = new URL(backend);
const [pathname, search] = path12.split("?");
result.pathname = pathname ? ensureLeadingSlash(pathname) : "";
if (search) {
result.search = `?${search}`;
}
return removeTrailingSlash(result.toString(), result.pathname);
} catch (error) {
console.warn("Failed to build URL:", path12, error);
return `https://kilocode.ai${path12 ? ensureLeadingSlash(path12) : ""}`;
}
}
function getApiUrl(path12 = "") {
return buildUrl(`/api${path12 ? ensureLeadingSlash(path12) : ""}`);
}
var ghostServiceSettingsSchema, commitRangeSchema, kiloCodeMetaDataSchema, fastApplyModelSchema, DEFAULT_KILOCODE_BACKEND_URL;
var init_kilocode = __esm({
"../packages/types/src/kilocode/kilocode.ts"() {
"use strict";
ghostServiceSettingsSchema = z.object({
enableAutoTrigger: z.boolean().optional(),
enableQuickInlineTaskKeybinding: z.boolean().optional(),
enableSmartInlineTaskKeybinding: z.boolean().optional(),
showGutterAnimation: z.boolean().optional(),
provider: z.string().optional(),
model: z.string().optional()
}).optional();
commitRangeSchema = z.object({
from: z.string(),
fromTimeStamp: z.number().optional(),
to: z.string()
});
kiloCodeMetaDataSchema = z.object({
commitRange: commitRangeSchema.optional()
});
fastApplyModelSchema = z.enum([
"auto",
"morph/morph-v3-fast",
"morph/morph-v3-large",
"relace/relace-apply-3"
]);
DEFAULT_KILOCODE_BACKEND_URL = "https://kilocode.ai";
}
});
// ../packages/types/src/message.ts
import { z as z2 } from "zod";
var clineAsks, clineAskSchema, clineSays, clineSaySchema, toolProgressStatusSchema, contextCondenseSchema, clineMessageSchema, tokenUsageSchema, queuedMessageSchema;
var init_message = __esm({
"../packages/types/src/message.ts"() {
"use strict";
init_kilocode();
clineAsks = [
"followup",
"command",
"command_output",
"completion_result",
"tool",
"api_req_failed",
"resume_task",
"resume_completed_task",
"mistake_limit_reached",
"browser_action_launch",
"use_mcp_server",
"auto_approval_max_req_reached",
// kilocode_change start
"payment_required_prompt",
// Added for the low credits dialog
"invalid_model",
"report_bug",
"condense"
// kilocode_change end
];
clineAskSchema = z2.enum(clineAsks);
clineSays = [
"error",
"api_req_started",
"api_req_finished",
"api_req_retried",
"api_req_retry_delayed",
"api_req_deleted",
"text",
"image",
"reasoning",
"completion_result",
"user_feedback",
"user_feedback_diff",
"command_output",
"shell_integration_warning",
"browser_action",
"browser_action_result",
"mcp_server_request_started",
"mcp_server_response",
"subtask_result",
"checkpoint_saved",
"rooignore_error",
"diff_error",
"condense_context",
"condense_context_error",
"codebase_search_result",
"user_edit_todos"
];
clineSaySchema = z2.enum(clineSays);
toolProgressStatusSchema = z2.object({
icon: z2.string().optional(),
text: z2.string().optional()
});
contextCondenseSchema = z2.object({
cost: z2.number(),
prevContextTokens: z2.number(),
newContextTokens: z2.number(),
summary: z2.string()
});
clineMessageSchema = z2.object({
ts: z2.number(),
type: z2.union([z2.literal("ask"), z2.literal("say")]),
ask: clineAskSchema.optional(),
say: clineSaySchema.optional(),
text: z2.string().optional(),
images: z2.array(z2.string()).optional(),
partial: z2.boolean().optional(),
reasoning: z2.string().optional(),
conversationHistoryIndex: z2.number().optional(),
checkpoint: z2.record(z2.string(), z2.unknown()).optional(),
progressStatus: toolProgressStatusSchema.optional(),
contextCondense: contextCondenseSchema.optional(),
isProtected: z2.boolean().optional(),
apiProtocol: z2.union([z2.literal("openai"), z2.literal("anthropic")]).optional(),
isAnswered: z2.boolean().optional(),
metadata: z2.object({
gpt5: z2.object({
previous_response_id: z2.string().optional(),
instructions: z2.string().optional(),
reasoning_summary: z2.string().optional()
}).optional(),
kiloCode: kiloCodeMetaDataSchema.optional()
}).optional()
});
tokenUsageSchema = z2.object({
totalTokensIn: z2.number(),
totalTokensOut: z2.number(),
totalCacheWrites: z2.number().optional(),
totalCacheReads: z2.number().optional(),
totalCost: z2.number(),
contextTokens: z2.number()
});
queuedMessageSchema = z2.object({
timestamp: z2.number(),
id: z2.string(),
text: z2.string(),
images: z2.array(z2.string()).optional()
});
}
});
// ../packages/types/src/tool.ts
import { z as z3 } from "zod";
var toolGroups, toolGroupsSchema, toolNames, toolNamesSchema, toolUsageSchema;
var init_tool = __esm({
"../packages/types/src/tool.ts"() {
"use strict";
toolGroups = ["read", "edit", "browser", "command", "mcp", "modes"];
toolGroupsSchema = z3.enum(toolGroups);
toolNames = [
"execute_command",
"read_file",
"write_to_file",
"apply_diff",
"insert_content",
"search_and_replace",
"search_files",
"list_files",
"list_code_definition_names",
"browser_action",
"use_mcp_tool",
"access_mcp_resource",
"ask_followup_question",
"attempt_completion",
"switch_mode",
"new_task",
"fetch_instructions",
"codebase_search",
// kilocode_change start
"edit_file",
"new_rule",
"report_bug",
"condense",
// kilocode_change end
"update_todo_list",
"run_slash_command",
"generate_image"
];
toolNamesSchema = z3.enum(toolNames);
toolUsageSchema = z3.record(
toolNamesSchema,
z3.object({
attempts: z3.number(),
failures: z3.number()
})
);
}
});
// ../packages/types/src/events.ts
import { z as z4 } from "zod";
var rooCodeEventsSchema, taskEventSchema;
var init_events2 = __esm({
"../packages/types/src/events.ts"() {
"use strict";
init_message();
init_tool();
rooCodeEventsSchema = z4.object({
["taskCreated" /* TaskCreated */]: z4.tuple([z4.string()]),
["taskStarted" /* TaskStarted */]: z4.tuple([z4.string()]),
["taskCompleted" /* TaskCompleted */]: z4.tuple([
z4.string(),
tokenUsageSchema,
toolUsageSchema,
z4.object({
isSubtask: z4.boolean()
})
]),
["taskAborted" /* TaskAborted */]: z4.tuple([z4.string()]),
["taskFocused" /* TaskFocused */]: z4.tuple([z4.string()]),
["taskUnfocused" /* TaskUnfocused */]: z4.tuple([z4.string()]),
["taskActive" /* TaskActive */]: z4.tuple([z4.string()]),
["taskInteractive" /* TaskInteractive */]: z4.tuple([z4.string()]),
["taskResumable" /* TaskResumable */]: z4.tuple([z4.string()]),
["taskIdle" /* TaskIdle */]: z4.tuple([z4.string()]),
["taskPaused" /* TaskPaused */]: z4.tuple([z4.string()]),
["taskUnpaused" /* TaskUnpaused */]: z4.tuple([z4.string()]),
["taskSpawned" /* TaskSpawned */]: z4.tuple([z4.string(), z4.string()]),
["message" /* Message */]: z4.tuple([
z4.object({
taskId: z4.string(),
action: z4.union([z4.literal("created"), z4.literal("updated")]),
message: clineMessageSchema
})
]),
["taskModeSwitched" /* TaskModeSwitched */]: z4.tuple([z4.string(), z4.string()]),
["taskAskResponded" /* TaskAskResponded */]: z4.tuple([z4.string()]),
["taskUserMessage" /* TaskUserMessage */]: z4.tuple([z4.string()]),
["taskToolFailed" /* TaskToolFailed */]: z4.tuple([z4.string(), toolNamesSchema, z4.string()]),
["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */]: z4.tuple([z4.string(), tokenUsageSchema]),
["modeChanged" /* ModeChanged */]: z4.tuple([z4.string()]),
["providerProfileChanged" /* ProviderProfileChanged */]: z4.tuple([z4.object({ name: z4.string(), provider: z4.string() })])
});
taskEventSchema = z4.discriminatedUnion("eventName", [
// Task Provider Lifecycle
z4.object({
eventName: z4.literal("taskCreated" /* TaskCreated */),
payload: rooCodeEventsSchema.shape["taskCreated" /* TaskCreated */],
taskId: z4.number().optional()
}),
// Task Lifecycle
z4.object({
eventName: z4.literal("taskStarted" /* TaskStarted */),
payload: rooCodeEventsSchema.shape["taskStarted" /* TaskStarted */],
taskId: z4.number().optional()
}),
z4.object({
eventName: z4.literal("taskCompleted" /* TaskCompleted */),
payload: rooCodeEventsSchema.shape["taskCompleted" /* TaskCompleted */],
taskId: z4.number().optional()
}),
z4.object({
eventName: z4.literal("taskAborted" /* TaskAborted */),
payload: rooCodeEventsSchema.shape["taskAborted" /* TaskAborted */],
taskId: z4.number().optional()
}),
z4.object({
eventName: z4.literal("taskFocused" /* TaskFocused */),
payload: rooCodeEventsSchema.shape["taskFocused" /* TaskFocused */],
taskId: z4.number().optional()
}),
z4.object({
eventName: z4.literal("taskUnfocused" /* TaskUnfocused */),
payload: rooCodeEventsSchema.shape["taskUnfocused" /* TaskUnfocused */],
taskId: z4.number().optional()
}),
z4.object({
eventName: z4.literal("taskActive" /* TaskActive */),
payload: rooCodeEventsSchema.shape["taskActive" /* TaskActive */],
taskId: z4.number().optional()
}),
z4.object({
eventName: z4.literal("taskInteractive" /* TaskInteractive */),
payload: rooCodeEventsSchema.shape["taskInteractive" /* TaskInteractive */],
taskId: z4.number().optional()
}),
z4.object({
eventName: z4.literal("taskResumable" /* TaskResumable */),
payload: rooCodeEventsSchema.shape["taskResumable" /* TaskResumable */],
taskId: z4.number().optional()
}),
z4.object({
eventName: z4.literal("taskIdle" /* TaskIdle */),
payload: rooCodeEventsSchema.shape["taskIdle" /* TaskIdle */],
taskId: z4.number().optional()
}),
// Subtask Lifecycle
z4.object({
eventName: z4.literal("taskPaused" /* TaskPaused */),
payload: rooCodeEventsSchema.shape["taskPaused" /* TaskPaused */],
taskId: z4.number().optional()
}),
z4.object({
eventName: z4.literal("taskUnpaused" /* TaskUnpaused */),
payload: rooCodeEventsSchema.shape["taskUnpaused" /* TaskUnpaused */],
taskId: z4.number().optional()
}),
z4.object({
eventName: z4.literal("taskSpawned" /* TaskSpawned */),
payload: rooCodeEventsSchema.shape["taskSpawned" /* TaskSpawned */],
taskId: z4.number().optional()
}),
// Task Execution
z4.object({
eventName: z4.literal("message" /* Message */),
payload: rooCodeEventsSchema.shape["message" /* Message */],
taskId: z4.number().optional()
}),
z4.object({
eventName: z4.literal("taskModeSwitched" /* TaskModeSwitched */),
payload: rooCodeEventsSchema.shape["taskModeSwitched" /* TaskModeSwitched */],
taskId: z4.number().optional()
}),
z4.object({
eventName: z4.literal("taskAskResponded" /* TaskAskResponded */),
payload: rooCodeEventsSchema.shape["taskAskResponded" /* TaskAskResponded */],
taskId: z4.number().optional()
}),
// Task Analytics
z4.object({
eventName: z4.literal("taskToolFailed" /* TaskToolFailed */),
payload: rooCodeEventsSchema.shape["taskToolFailed" /* TaskToolFailed */],
taskId: z4.number().optional()
}),
z4.object({
eventName: z4.literal("taskTokenUsageUpdated" /* TaskTokenUsageUpdated */),
payload: rooCodeEventsSchema.shape["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */],
taskId: z4.number().optional()
}),
// Evals
z4.object({
eventName: z4.literal("evalPass" /* EvalPass */),
payload: z4.undefined(),
taskId: z4.number()
}),
z4.object({
eventName: z4.literal("evalFail" /* EvalFail */),
payload: z4.undefined(),
taskId: z4.number()
})
]);
}
});
// ../packages/types/src/task.ts
import { z as z5 } from "zod";
var TaskStatus, taskMetadataSchema;
var init_task = __esm({
"../packages/types/src/task.ts"() {
"use strict";
TaskStatus = /* @__PURE__ */ ((TaskStatus2) => {
TaskStatus2["Running"] = "running";
TaskStatus2["Interactive"] = "interactive";
TaskStatus2["Resumable"] = "resumable";
TaskStatus2["Idle"] = "idle";
TaskStatus2["None"] = "none";
return TaskStatus2;
})(TaskStatus || {});
taskMetadataSchema = z5.object({
task: z5.string().optional(),
images: z5.array(z5.string()).optional()
});
}
});
// ../packages/types/src/model.ts
import { z as z6 } from "zod";
var reasoningEfforts, reasoningEffortsSchema, reasoningEffortWithMinimalSchema, verbosityLevels, verbosityLevelsSchema, serviceTiers, serviceTierSchema, modelParameters, modelParametersSchema, modelInfoSchema;
var init_model = __esm({
"../packages/types/src/model.ts"() {
"use strict";
reasoningEfforts = ["low", "medium", "high"];
reasoningEffortsSchema = z6.enum(reasoningEfforts);
reasoningEffortWithMinimalSchema = z6.union([reasoningEffortsSchema, z6.literal("minimal")]);
verbosityLevels = ["low", "medium", "high"];
verbosityLevelsSchema = z6.enum(verbosityLevels);
serviceTiers = ["default", "flex", "priority"];
serviceTierSchema = z6.enum(serviceTiers);
modelParameters = ["max_tokens", "temperature", "reasoning", "include_reasoning"];
modelParametersSchema = z6.enum(modelParameters);
modelInfoSchema = z6.object({
maxTokens: z6.number().nullish(),
maxThinkingTokens: z6.number().nullish(),
contextWindow: z6.number(),
supportsImages: z6.boolean().optional(),
supportsComputerUse: z6.boolean().optional(),
supportsPromptCache: z6.boolean(),
// Capability flag to indicate whether the model supports an output verbosity parameter
supportsVerbosity: z6.boolean().optional(),
supportsReasoningBudget: z6.boolean().optional(),
// Capability flag to indicate whether the model supports temperature parameter
supportsTemperature: z6.boolean().optional(),
requiredReasoningBudget: z6.boolean().optional(),
supportsReasoningEffort: z6.boolean().optional(),
supportedParameters: z6.array(modelParametersSchema).optional(),
inputPrice: z6.number().optional(),
outputPrice: z6.number().optional(),
cacheWritesPrice: z6.number().optional(),
cacheReadsPrice: z6.number().optional(),
description: z6.string().optional(),
reasoningEffort: reasoningEffortsSchema.optional(),
minTokensPerCachePoint: z6.number().optional(),
maxCachePoints: z6.number().optional(),
cachableFields: z6.array(z6.string()).optional(),
// kilocode_change start
displayName: z6.string().nullish(),
preferredIndex: z6.number().nullish(),
// kilocode_change end
// Flag to indicate if the model is deprecated and should not be used
deprecated: z6.boolean().optional(),
/**
* Service tiers with pricing information.
* Each tier can have a name (for OpenAI service tiers) and pricing overrides.
* The top-level input/output/cache* fields represent the default/standard tier.
*/
tiers: z6.array(
z6.object({
name: serviceTierSchema.optional(),
// Service tier name (flex, priority, etc.)
contextWindow: z6.number(),
inputPrice: z6.number().optional(),
outputPrice: z6.number().optional(),
cacheWritesPrice: z6.number().optional(),
cacheReadsPrice: z6.number().optional()
})
).optional()
});
}
});
// ../packages/types/src/codebase-index.ts
import { z as z7 } from "zod";
var CODEBASE_INDEX_DEFAULTS, codebaseIndexConfigSchema, codebaseIndexModelsSchema, codebaseIndexProviderSchema;
var init_codebase_index = __esm({
"../packages/types/src/codebase-index.ts"() {
"use strict";
CODEBASE_INDEX_DEFAULTS = {
MIN_SEARCH_RESULTS: 10,
MAX_SEARCH_RESULTS: 200,
DEFAULT_SEARCH_RESULTS: 50,
SEARCH_RESULTS_STEP: 10,
MIN_SEARCH_SCORE: 0,
MAX_SEARCH_SCORE: 1,
DEFAULT_SEARCH_MIN_SCORE: 0.4,
SEARCH_SCORE_STEP: 0.05
};
codebaseIndexConfigSchema = z7.object({
codebaseIndexEnabled: z7.boolean().optional(),
codebaseIndexQdrantUrl: z7.string().optional(),
codebaseIndexEmbedderProvider: z7.enum(["openai", "ollama", "openai-compatible", "gemini", "mistral", "vercel-ai-gateway"]).optional(),
codebaseIndexEmbedderBaseUrl: z7.string().optional(),
codebaseIndexEmbedderModelId: z7.string().optional(),
codebaseIndexEmbedderModelDimension: z7.number().optional(),
codebaseIndexSearchMinScore: z7.number().min(0).max(1).optional(),
codebaseIndexSearchMaxResults: z7.number().min(CODEBASE_INDEX_DEFAULTS.MIN_SEARCH_RESULTS).max(CODEBASE_INDEX_DEFAULTS.MAX_SEARCH_RESULTS).optional(),
// OpenAI Compatible specific fields
codebaseIndexOpenAiCompatibleBaseUrl: z7.string().optional(),
codebaseIndexOpenAiCompatibleModelDimension: z7.number().optional()
});
codebaseIndexModelsSchema = z7.object({
openai: z7.record(z7.string(), z7.object({ dimension: z7.number() })).optional(),
ollama: z7.record(z7.string(), z7.object({ dimension: z7.number() })).optional(),
"openai-compatible": z7.record(z7.string(), z7.object({ dimension: z7.number() })).optional(),
gemini: z7.record(z7.string(), z7.object({ dimension: z7.number() })).optional(),
mistral: z7.record(z7.string(), z7.object({ dimension: z7.number() })).optional(),
"vercel-ai-gateway": z7.record(z7.string(), z7.object({ dimension: z7.number() })).optional()
});
codebaseIndexProviderSchema = z7.object({
codeIndexOpenAiKey: z7.string().optional(),
codeIndexQdrantApiKey: z7.string().optional(),
codebaseIndexOpenAiCompatibleBaseUrl: z7.string().optional(),
codebaseIndexOpenAiCompatibleApiKey: z7.string().optional(),
codebaseIndexOpenAiCompatibleModelDimension: z7.number().optional(),
codebaseIndexGeminiApiKey: z7.string().optional(),
codebaseIndexMistralApiKey: z7.string().optional(),
codebaseIndexVercelAiGatewayApiKey: z7.string().optional()
});
}
});
// ../packages/types/src/providers/anthropic.ts
var anthropicDefaultModelId, anthropicModels;
var init_anthropic = __esm({
"../packages/types/src/providers/anthropic.ts"() {
"use strict";
anthropicDefaultModelId = "claude-sonnet-4-20250514";
anthropicModels = {
"claude-sonnet-4-5": {
maxTokens: 64e3,
// Overridden to 8k if `enableReasoningEffort` is false.
contextWindow: 2e5,
// Default 200K, extendable to 1M with beta flag 'context-1m-2025-08-07'
supportsImages: true,
supportsComputerUse: true,
supportsPromptCache: true,
inputPrice: 3,
// $3 per million input tokens (≤200K context)
outputPrice: 15,
// $15 per million output tokens (≤200K context)
cacheWritesPrice: 3.75,
// $3.75 per million tokens
cacheReadsPrice: 0.3,
// $0.30 per million tokens
supportsReasoningBudget: true,
// Tiered pricing for extended context (requires beta flag 'context-1m-2025-08-07')
tiers: [
{
contextWindow: 1e6,
// 1M tokens with beta flag
inputPrice: 6,
// $6 per million input tokens (>200K context)
outputPrice: 22.5,
// $22.50 per million output tokens (>200K context)
cacheWritesPrice: 7.5,
// $7.50 per million tokens (>200K context)
cacheReadsPrice: 0.6
// $0.60 per million tokens (>200K context)
}
]
},
"claude-sonnet-4-20250514": {
maxTokens: 64e3,
// Overridden to 8k if `enableReasoningEffort` is false.
contextWindow: 2e5,
// Default 200K, extendable to 1M with beta flag 'context-1m-2025-08-07'
supportsImages: true,
supportsComputerUse: true,
supportsPromptCache: true,
inputPrice: 3,
// $3 per million input tokens (≤200K context)
outputPrice: 15,
// $15 per million output tokens (≤200K context)
cacheWritesPrice: 3.75,
// $3.75 per million tokens
cacheReadsPrice: 0.3,
// $0.30 per million tokens
supportsReasoningBudget: true,
// Tiered pricing for extended context (requires beta flag 'context-1m-2025-08-07')
tiers: [
{
contextWindow: 1e6,
// 1M tokens with beta flag
inputPrice: 6,
// $6 per million input tokens (>200K context)
outputPrice: 22.5,
// $22.50 per million output tokens (>200K context)
cacheWritesPrice: 7.5,
// $7.50 per million tokens (>200K context)
cacheReadsPrice: 0.6
// $0.60 per million tokens (>200K context)
}
]
},
"claude-opus-4-1-20250805": {
maxTokens: 32e3,
// kilocode_change: https://openrouter.ai/anthropic/claude-opus-4.1/providers
contextWindow: 2e5,
supportsImages: true,
supportsComputerUse: true,
supportsPromptCache: true,
inputPrice: 15,
// $15 per million input tokens
outputPrice: 75,
// $75 per million output tokens
cacheWritesPrice: 18.75,
// $18.75 per million tokens
cacheReadsPrice: 1.5,
// $1.50 per million tokens
supportsReasoningBudget: true
},
"claude-opus-4-20250514": {
maxTokens: 32e3,
// Overridden to 8k if `enableReasoningEffort` is false.
contextWindow: 2e5,
supportsImages: true,
supportsComputerUse: true,
supportsPromptCache: true,
inputPrice: 15,
// $15 per million input tokens
outputPrice: 75,
// $75 per million output tokens
cacheWritesPrice: 18.75,
// $18.75 per million tokens
cacheReadsPrice: 1.5,
// $1.50 per million tokens
supportsReasoningBudget: true
},
"claude-3-7-sonnet-20250219:thinking": {
maxTokens: 128e3,
// Unlocked by passing `beta` flag to the model. Otherwise, it's 64k.
contextWindow: 2e5,
supportsImages: true,
supportsComputerUse: true,
supportsPromptCache: true,
inputPrice: 3,
// $3 per million input tokens
outputPrice: 15,
// $15 per million output tokens
cacheWritesPrice: 3.75,
// $3.75 per million tokens
cacheReadsPrice: 0.3,
// $0.30 per million tokens
supportsReasoningBudget: true,
requiredReasoningBudget: true
},
"claude-3-7-sonnet-20250219": {
maxTokens: 8192,
// Since we already have a `:thinking` virtual model we aren't setting `supportsReasoningBudget: true` here.
contextWindow: 2e5,
supportsImages: true,
supportsComputerUse: true,
supportsPromptCache: true,
inputPrice: 3,
// $3 per million input tokens
outputPrice: 15,
// $15 per million output tokens
cacheWritesPrice: 3.75,
// $3.75 per million tokens
cacheReadsPrice: 0.3
// $0.30 per million tokens
},
"claude-3-5-sonnet-20241022": {
maxTokens: 8192,
contextWindow: 2e5,
supportsImages: true,
supportsComputerUse: true,
supportsPromptCache: true,
inputPrice: 3,
// $3 per million input tokens
outputPrice: 15,
// $15 per million output tokens
cacheWritesPrice: 3.75,
// $3.75 per million tokens
cacheReadsPrice: 0.3
// $0.30 per million tokens
},
"claude-3-5-haiku-20241022": {
maxTokens: 8192,
contextWindow: 2e5,
supportsImages: false,
supportsPromptCache: true,
inputPrice: 1,
outputPrice: 5,
cacheWritesPrice: 1.25,
cacheReadsPrice: 0.1
},
"claude-3-opus-20240229": {
maxTokens: 4096,
contextWindow: 2e5,
supportsImages: true,
supportsPromptCache: true,
inputPrice: 15,
outputPrice: 75,
cacheWritesPrice: 18.75,
cacheReadsPrice: 1.5
},
"claude-3-haiku-20240307": {
maxTokens: 4096,
contextWindow: 2e5,
supportsImages: true,
supportsPromptCache: true,
inputPrice: 0.25,
outputPrice: 1.25,
cacheWritesPrice: 0.3,
cacheReadsPrice: 0.03
},
"claude-haiku-4-5-20251001": {
maxTokens: 64e3,
contextWindow: 2e5,
supportsImages: true,
supportsPromptCache: true,
inputPrice: 1,
outputPrice: 5,
cacheWritesPrice: 1.25,
cacheReadsPrice: 0.1,
supportsReasoningBudget: true,
description: "Claude Haiku 4.5 delivers near-frontier intelligence at lightning speeds with extended thinking, vision, and multilingual support."
}
};
}
});
// ../packages/types/src/providers/bedrock.ts
var bedrockDefaultModelId, bedrockModels, BEDROCK_REGIONS;
var init_bedrock = __esm({
"../packages/types/src/providers/bedrock.ts"() {
"use strict";
bedrockDefaultModelId = "anthropic.claude-sonnet-4-20250514-v1:0";
bedrockModels = {
"anthropic.claude-sonnet-4-5-20250929-v1:0": {
maxTokens: 8192,
contextWindow: 2e5,
supportsImages: true,
supportsComputerUse: true,
supportsPromptCache: true,
supportsReasoningBudget: true,
inputPrice: 3,
outputPrice: 15,
cacheWritesPrice: 3.75,
cacheReadsPrice: 0.3,
minTokensPerCachePoint: 1024,
maxCachePoints: 4,
cachableFields: ["system", "messages", "tools"]
},
"amazon.nova-pro-v1:0": {
maxTokens: 5e3,
contextWindow: 3e5,
supportsImages: true,
supportsComputerUse: false,
supportsPromptCache: true,
inputPrice: 0.8,
outputPrice: 3.2,
cacheWritesPrice: 0.8,
// per million tokens
cacheReadsPrice: 0.2,
// per million tokens
minTokensPerCachePoint: 1,
maxCachePoints: 1,
cachableFields: ["system"]
},
"amazon.nova-pro-latency-optimized-v1:0": {
maxTokens: 5e3,
contextWindow: 3e5,
supportsImages: true,
supportsComputerUse: false,
supportsPromptCache: false,
inputPrice: 1,
outputPrice: 4,
cacheWritesPrice: 1,
// per million tokens
cacheReadsPrice: 0.25,
// per million tokens
description: "Amazon Nova Pro with latency optimized inference"
},
"amazon.nova-lite-v1:0": {
maxTokens: 5e3,
contextWindow: 3e5,
supportsImages: true,
supportsComputerUse: false,
supportsPromptCache: true,
inputPrice: 0.06,
outputPrice: 0.24,
cacheWritesPrice: 0.06,
// per million tokens
cacheReadsPrice: 0.015,
// per million tokens
minTokensPerCachePoint: 1,
maxCachePoints: 1,
cachableFields: ["system"]
},
"amazon.nova-micro-v1:0": {
maxTokens: 5e3,
contextWindow: 128e3,
supportsImages: false,
supportsComputerUse: false,
supportsPromptCache: true,
inputPrice: 0.035,
outputPrice: 0.14,
cacheWritesPrice: 0.035,
// per million tokens
cacheReadsPrice: 875e-5,
// per million tokens
minTokensPerCachePoint: 1,
maxCachePoints: 1,
cachableFields: ["system"]
},
"anthropic.claude-sonnet-4-20250514-v1:0": {
maxTokens: 8192,
contextWindow: 2e5,
supportsImages: true,
supportsComputerUse: true,
supportsPromptCache: true,
supportsReasoningBudget: true,
inputPrice: 3,
outputPrice: 15,
cacheWritesPrice: 3.75,
cacheReadsPrice: 0.3,
minTokensPerCachePoint: 1024,
maxCachePoints: 4,
cachableFields: ["system", "messages", "tools"]
},
"anthropic.claude-opus-4-1-20250805-v1:0": {
maxTokens: 8192,
contextWindow: 2e5,
supportsImages: true,
supportsComputerUse: true,
supportsPromptCache: true,
supportsReasoningBudget: true,
inputPrice: 15,
outputPrice: 75,
cacheWritesPrice: 18.75,
cacheReadsPrice: 1.5,
minTokensPerCachePoint: 1024,
maxCachePoints: 4,
cachableFields: ["system", "messages", "tools"]
},
"anthropic.claude-opus-4-20250514-v1:0": {
maxTokens: 8192,
contextWindow: 2e5,
supportsImages: true,
supportsComputerUse: true,
supportsPromptCache: true,
supportsReasoningBudget: true,
inputPrice: 15,
outputPrice: 75,
cacheWritesPrice: 18.75,
cacheReadsPrice: 1.5,
minTokensPerCachePoint: 1024,
maxCachePoints: 4,
cachableFields: ["system", "messages", "tools"]
},
"anthropic.claude-3-7-sonnet-20250219-v1:0": {
maxTokens: 8192,
contextWindow: 2e5,
supportsImages: true,
supportsComputerUse: true,
supportsPromptCache: true,
supportsReasoningBudget: true,
inputPrice: 3,
outputPrice: 15,
cacheWritesPrice: 3.75,
cacheReadsPrice: 0.3,
minTokensPerCachePoint: 1024,
maxCachePoints: 4,
cachableFields: ["system", "messages", "tools"]
},
"anthropic.claude-3-5-sonnet-20241022-v2:0": {
maxTokens: 8192,
contextWindow: 2e5,
supportsImages: true,
supportsComputerUse: true,
supportsPromptCache: true,
inputPrice: 3,
outputPrice: 15,
cacheWritesPrice: 3.75,
cacheReadsPrice: 0.3,
minTokensPerCachePoint: 1024,
maxCachePoints: 4,
cachableFields: ["system", "messages", "tools"]
},
"anthropic.claude-3-5-haiku-20241022-v1:0": {
maxTokens: 8192,
contextWindow: 2e5,
supportsImages: false,
supportsPromptCache: true,
inputPrice: 0.8,
outputPrice: 4,
cacheWritesPrice: 1,
cacheReadsPrice: 0.08,
minTokensPerCachePoint: 2048,
maxCachePoints: 4,
cachableFields: ["system", "messages", "tools"]
},
"anthropic.claude-haiku-4-5-20251001-v1:0": {
maxTokens: 8192,
contextWindow: 2e5,
supportsImages: true,
supportsPromptCache: true,
supportsReasoningBudget: true,
inputPrice: 1,
outputPrice: 5,
cacheWritesPrice: 1.25,
// 5m cache writes
cacheReadsPrice: 0.1,
// cache hits / refreshes
minTokensPerCachePoint: 2048,
maxCachePoints: 4,