oricore 1.0.0

package/dist/core/at.d.ts

@@ -0,0 +1,26 @@
+import type { LanguageModelV2Prompt } from '@ai-sdk/provider';
+export declare class At {
+    private userPrompt;
+    private cwd;
+    constructor(opts: {
+        userPrompt: string;
+        cwd: string;
+    });
+    getContent(): string | null;
+    private extractAtPaths;
+    private renderDirectoriesToTree;
+    renderFilesToXml(fileEntries: Array<{
+        filePath: string;
+        lineRange?: {
+            start: number;
+            end?: number;
+        };
+    }>): string;
+    getAllFilesInDirectory(dirPath: string): string[];
+    private truncateLine;
+    private processFileContent;
+    static normalizeLanguageV2Prompt(opts: {
+        input: LanguageModelV2Prompt;
+        cwd: string;
+    }): LanguageModelV2Prompt;
+}

package/dist/core/backgroundTaskManager.d.ts

@@ -0,0 +1,27 @@
+export interface BackgroundTask {
+    id: string;
+    command: string;
+    pid: number;
+    pgid?: number;
+    status: 'running' | 'completed' | 'killed' | 'failed';
+    createdAt: number;
+    output: string;
+    exitCode: number | null;
+}
+interface CreateTaskInput {
+    command: string;
+    pid: number;
+    pgid?: number;
+}
+export declare class BackgroundTaskManager {
+    private tasks;
+    createTask(input: CreateTaskInput): string;
+    getTask(id: string): BackgroundTask | null;
+    getAllTasks(): BackgroundTask[];
+    appendOutput(id: string, output: string): void;
+    updateTaskStatus(id: string, status: BackgroundTask['status'], exitCode?: number | null): void;
+    deleteTask(id: string): void;
+    private isProcessAlive;
+    killTask(id: string): Promise<boolean>;
+}
+export {};

package/dist/core/compact.d.ts

@@ -0,0 +1,9 @@
+import type { NormalizedMessage } from '../core/message';
+import type { ModelInfo } from '../core/model';
+type CompactOptions = {
+    messages: NormalizedMessage[];
+    model: ModelInfo;
+};
+export declare const COMPACT_MESSAGE = "Chat history compacted successfully.";
+export declare function compact(opts: CompactOptions): Promise<string>;
+export {};

package/dist/core/config.d.ts

@@ -0,0 +1,103 @@
+import type { Provider } from '../core/model';
+export type McpStdioServerConfig = {
+    type: 'stdio';
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+    disable?: boolean;
+};
+export type McpSSEServerConfig = {
+    type: 'sse';
+    url: string;
+    disable?: boolean;
+    headers?: Record<string, string>;
+};
+export type McpHttpServerConfig = {
+    type: 'http';
+    url: string;
+    disable?: boolean;
+    headers?: Record<string, string>;
+};
+export type McpServerConfig = McpStdioServerConfig | McpSSEServerConfig | McpHttpServerConfig;
+export type ApprovalMode = 'default' | 'autoEdit' | 'yolo';
+export type AgentConfig = {
+    model?: string;
+};
+export type CommitConfig = {
+    language: string;
+    systemPrompt?: string;
+    model?: string;
+};
+export type ProviderConfig = Partial<Omit<Provider, 'createModel'>>;
+export type DesktopConfig = {
+    theme?: 'light' | 'dark' | 'system';
+    sendMessageWith?: 'enter' | 'cmdEnter';
+    terminalFont?: string;
+    terminalFontSize?: number;
+};
+export type Config = {
+    model: string;
+    planModel: string;
+    smallModel?: string;
+    visionModel?: string;
+    language: string;
+    quiet: boolean;
+    approvalMode: ApprovalMode;
+    plugins: string[];
+    mcpServers: Record<string, McpServerConfig>;
+    provider?: Record<string, ProviderConfig>;
+    systemPrompt?: string;
+    todo?: boolean;
+    /**
+     * Controls whether automatic conversation compression is enabled.
+     * When set to false, conversation history will accumulate and context limit will be exceeded.
+     *
+     * @default true
+     */
+    autoCompact?: boolean;
+    commit?: CommitConfig;
+    outputStyle?: string;
+    outputFormat?: 'text' | 'stream-json' | 'json';
+    autoUpdate?: boolean;
+    temperature?: number;
+    httpProxy?: string;
+    desktop?: DesktopConfig;
+    /**
+     * Extensions configuration for third-party custom agents.
+     * Allows arbitrary nested configuration without validation.
+     */
+    extensions?: Record<string, any>;
+    /**
+     * Tools configuration for enabling/disabling specific tools.
+     * Key is the tool name, value is boolean (false to disable).
+     */
+    tools?: Record<string, boolean>;
+    /**
+     * Agent configuration for customizing agent behavior per agent type.
+     * Example: { explore: { model: "anthropic/claude-haiku-4" } }
+     */
+    agent?: Record<string, AgentConfig>;
+    /**
+     * Notification configuration.
+     * - true: play default sound (Funk/warning)
+     * - false: disabled
+     * - string: custom sound name (e.g., "Glass", "Ping")
+     * - object: extended notification config (reserved for future use, e.g., url)
+     */
+    notification?: boolean | string;
+};
+export declare const GLOBAL_ONLY_KEYS: string[];
+export declare class ConfigManager {
+    globalConfig: Partial<Config>;
+    projectConfig: Partial<Config>;
+    argvConfig: Partial<Config>;
+    globalConfigPath: string;
+    projectConfigPath: string;
+    constructor(cwd: string, productName: string, argvConfig: Partial<Config>);
+    get config(): Config;
+    removeConfig(global: boolean, key: string, values?: string[]): void;
+    addConfig(global: boolean, key: string, values: string[]): void;
+    getConfig(global: boolean, key: string): any;
+    setConfig(global: boolean, key: string, value: string): void;
+    updateConfig(global: boolean, newConfig: Partial<Config>): void;
+}

package/dist/core/constants.d.ts

@@ -0,0 +1,32 @@
+export declare const PRODUCT_NAME = "OriCore";
+export declare const PRODUCT_ASCII_ART: string;
+export declare const DEFAULT_OUTPUT_STYLE_NAME = "Default";
+export declare const IMAGE_EXTENSIONS: Set<string>;
+export declare const BINARY_EXTENSIONS: Set<string>;
+export declare const CANCELED_MESSAGE_TEXT = "[Request interrupted by user]";
+export declare enum TOOL_NAMES {
+    TODO_WRITE = "todoWrite",
+    BASH = "bash",
+    BASH_OUTPUT = "bash_output",
+    KILL_BASH = "kill_bash",
+    GREP = "grep",
+    ASK_USER_QUESTION = "AskUserQuestion",
+    READ = "read",
+    GLOB = "glob",
+    WRITE = "write",
+    EDIT = "edit",
+    LS = "ls",
+    TASK = "task"
+}
+export declare const BASH_EVENTS: {
+    readonly PROMPT_BACKGROUND: "bash:prompt_background";
+    readonly MOVE_TO_BACKGROUND: "bash:move_to_background";
+    readonly BACKGROUND_MOVED: "bash:background_moved";
+};
+export declare const MIN_TOKEN_THRESHOLD: number;
+export declare const BACKGROUND_THRESHOLD_MS = 2000;
+export declare enum AGENT_TYPE {
+    EXPLORE = "Explore",
+    PLAN = "Plan",
+    GENERAL_PURPOSE = "GeneralPurpose"
+}

package/dist/core/context.d.ts

@@ -0,0 +1,57 @@
+import { AgentManager } from '../agent/agent/agentManager';
+import { BackgroundTaskManager } from './backgroundTaskManager';
+import { type Config } from '../core/config';
+import { MCPManager } from '../mcp/mcp';
+import type { MessageBus } from '../communication/messageBus';
+import { Paths } from './paths';
+import { type Plugin, type PluginApplyOpts, PluginManager } from '../core/plugin';
+import { SkillManager } from '../skill/skill';
+type ContextOpts = {
+    cwd: string;
+    productName: string;
+    productASCIIArt?: string;
+    version: string;
+    config: Config;
+    pluginManager: PluginManager;
+    paths: Paths;
+    argvConfig: Record<string, any>;
+    mcpManager: MCPManager;
+    backgroundTaskManager: BackgroundTaskManager;
+    skillManager?: SkillManager;
+    messageBus?: MessageBus;
+    agentManager?: AgentManager;
+    plugins: (string | Plugin)[];
+    fetch?: typeof globalThis.fetch;
+};
+export type ContextCreateOpts = {
+    cwd: string;
+    productName: string;
+    productASCIIArt?: string;
+    version: string;
+    argvConfig: Record<string, any>;
+    plugins: (string | Plugin)[];
+    messageBus?: MessageBus;
+    fetch?: typeof globalThis.fetch;
+};
+export declare class Context {
+    #private;
+    cwd: string;
+    productName: string;
+    productASCIIArt?: string;
+    version: string;
+    config: Config;
+    paths: Paths;
+    argvConfig: Record<string, any>;
+    mcpManager: MCPManager;
+    backgroundTaskManager: BackgroundTaskManager;
+    skillManager?: SkillManager;
+    messageBus?: MessageBus;
+    agentManager?: AgentManager;
+    plugins: (string | Plugin)[];
+    fetch?: typeof globalThis.fetch;
+    constructor(opts: ContextOpts);
+    apply(applyOpts: Omit<PluginApplyOpts, 'pluginContext'>): Promise<any>;
+    destroy(): Promise<void>;
+    static create(opts: ContextCreateOpts): Promise<Context>;
+}
+export {};

package/dist/core/globalData.d.ts

@@ -0,0 +1,21 @@
+export declare class GlobalData {
+    private globalDataPath;
+    constructor({ globalDataPath }: {
+        globalDataPath: string;
+    });
+    private readData;
+    private writeData;
+    getProjectHistory({ cwd }: {
+        cwd: string;
+    }): string[];
+    addProjectHistory({ cwd, history }: {
+        cwd: string;
+        history: string;
+    }): void;
+    getProjectLastAccessed({ cwd }: {
+        cwd: string;
+    }): number | null;
+    updateProjectLastAccessed({ cwd }: {
+        cwd: string;
+    }): void;
+}

package/dist/core/history.d.ts

@@ -0,0 +1,24 @@
+import type { LanguageModelV2Message } from '@ai-sdk/provider';
+import type { Message, NormalizedMessage } from '../core/message';
+import type { ModelInfo } from '../core/model';
+export type OnMessage = (message: NormalizedMessage) => Promise<void>;
+export type HistoryOpts = {
+    messages: NormalizedMessage[];
+    onMessage?: OnMessage;
+};
+export declare class History {
+    #private;
+    messages: NormalizedMessage[];
+    onMessage?: OnMessage;
+    constructor(opts: HistoryOpts);
+    addMessage(message: Message, uuid?: string): Promise<void>;
+    getMessagesToUuid(uuid: string): NormalizedMessage[];
+    toLanguageV2Messages(): LanguageModelV2Message[];
+    compress(model: ModelInfo): Promise<{
+        compressed: boolean;
+        summary?: undefined;
+    } | {
+        compressed: boolean;
+        summary: string;
+    }>;
+}

package/dist/core/ide.d.ts

@@ -0,0 +1,103 @@
+import WebSocket from 'ws';
+import { type InstallationResult } from '../utils/ide';
+interface BaseResponse {
+    success: boolean;
+    message?: string;
+}
+interface OpenFileResponse extends BaseResponse {
+    filePath?: string;
+}
+interface OpenDiffResponse extends BaseResponse {
+    message: string;
+}
+interface DiagnosticItem {
+    message: string;
+    severity: string;
+    range: {
+        start: {
+            line: number;
+            character: number;
+        };
+        end: {
+            line: number;
+            character: number;
+        };
+    };
+}
+interface DiagnosticsResponse {
+    diagnostics: Array<{
+        uri: string;
+        diagnostics: DiagnosticItem[];
+    }>;
+}
+interface EditorInfo {
+    filePath: string;
+    isActive: boolean;
+}
+interface OpenEditorsResponse {
+    editors: EditorInfo[];
+}
+interface WorkspaceFolder {
+    name: string;
+    uri: string;
+}
+interface WorkspaceFoldersResponse {
+    folders: WorkspaceFolder[];
+}
+export interface SelectionInfo {
+    filePath: string;
+    text: string;
+    selection: {
+        start: {
+            line: number;
+            character: number;
+        };
+        end: {
+            line: number;
+            character: number;
+        };
+    };
+}
+export interface SelectionResponse extends SelectionInfo {
+}
+export interface SelectionErrorResponse {
+    error: string;
+}
+interface CloseTabResponse extends BaseResponse {
+    message: string;
+}
+interface CloseAllDiffTabsResponse extends BaseResponse {
+    closedCount: number;
+}
+export type SelectionResult = SelectionResponse | SelectionErrorResponse;
+interface WSMessage {
+    id?: number;
+    error?: {
+        message: string;
+    };
+    result?: unknown;
+}
+export declare class IDE {
+    ws: WebSocket | null;
+    private requestId;
+    private pendingRequests;
+    constructor();
+    findPort(): Promise<number | undefined>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    handleMessage(message: WSMessage): void;
+    request(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    openFile(filePath: string, options?: {
+        preview?: boolean;
+    }): Promise<OpenFileResponse>;
+    openDiff(old_file_path: string, new_file_path: string, new_file_contents: string, tab_name: string): Promise<OpenDiffResponse>;
+    getWorkspaceFolders(): Promise<WorkspaceFoldersResponse>;
+    getOpenEditors(): Promise<OpenEditorsResponse>;
+    getDiagnostics(): Promise<DiagnosticsResponse>;
+    getCurrentSelection(): Promise<SelectionResult>;
+    getLatestSelection(): Promise<SelectionResult>;
+    closeTab(tab_name: string): Promise<CloseTabResponse>;
+    closeAllDiffTabs(): Promise<CloseAllDiffTabsResponse>;
+    setupIDEIntegration(terminal: string): Promise<InstallationResult | undefined>;
+}
+export {};

package/dist/core/jsonl.d.ts

@@ -0,0 +1,37 @@
+import type { NormalizedMessage } from './message';
+import type { StreamResult } from './loop';
+export declare class JsonlLogger {
+    filePath: string;
+    lastUuid: string | null;
+    constructor(opts: {
+        filePath: string;
+    });
+    getLatestUuid(): any;
+    addMessage(opts: {
+        message: NormalizedMessage & {
+            sessionId: string;
+        };
+    }): NormalizedMessage & {
+        sessionId: string;
+    };
+    addUserMessage(content: string, sessionId: string): NormalizedMessage & {
+        sessionId: string;
+    };
+}
+export declare class RequestLogger {
+    globalProjectDir: string;
+    constructor(opts: {
+        globalProjectDir: string;
+    });
+    private getFilePath;
+    logMetadata(opts: {
+        requestId: string;
+        prompt: StreamResult['prompt'];
+        model: StreamResult['model'];
+        tools: StreamResult['tools'];
+        request?: StreamResult['request'];
+        response?: StreamResult['response'];
+        error?: StreamResult['error'];
+    }): void;
+    logChunk(requestId: string, chunk: any): void;
+}

package/dist/core/llmsContext.d.ts

@@ -0,0 +1,14 @@
+import type { Context } from './context';
+export type LlmsContextCreateOpts = {
+    context: Context;
+    sessionId: string;
+    userPrompt: string | null;
+    additionalDirectories?: string[];
+};
+export declare class LlmsContext {
+    messages: string[];
+    constructor(opts: {
+        messages: string[];
+    });
+    static create(opts: LlmsContextCreateOpts): Promise<LlmsContext>;
+}

package/dist/core/loop.d.ts

@@ -0,0 +1,82 @@
+import type { LanguageModelV2FunctionTool, LanguageModelV2Prompt, SharedV2Headers } from '@ai-sdk/provider';
+import { type OnMessage } from '../core/history';
+import { type NormalizedMessage } from '../core/message';
+import type { ModelInfo } from '../core/model';
+import { type ReasoningEffort } from './thinking-config';
+import type { ToolApprovalResult, ToolResult, Tools, ToolUse } from '../tools/tool';
+import { Usage } from '../core/usage';
+export type LoopResult = {
+    success: true;
+    data: Record<string, any>;
+    metadata: {
+        turnsCount: number;
+        toolCallsCount: number;
+        duration: number;
+    };
+} | {
+    success: false;
+    error: {
+        type: 'tool_denied' | 'max_turns_exceeded' | 'api_error' | 'canceled';
+        message: string;
+        details?: Record<string, any>;
+    };
+};
+type StreamResultBase = {
+    requestId: string;
+    prompt: LanguageModelV2Prompt;
+    model: ModelInfo;
+    tools: LanguageModelV2FunctionTool[];
+};
+export type StreamResult = StreamResultBase & {
+    request?: {
+        body?: unknown;
+    };
+    response?: {
+        headers?: SharedV2Headers;
+        statusCode?: number;
+        body?: unknown;
+    };
+    error?: any;
+};
+export type ResponseFormat = {
+    type: 'text';
+} | {
+    type: 'json';
+    schema?: any;
+    name?: string;
+    description?: string;
+};
+export type ThinkingConfig = {
+    effort: ReasoningEffort;
+};
+type RunLoopOpts = {
+    input: string | NormalizedMessage[];
+    model: ModelInfo;
+    tools: Tools;
+    cwd: string;
+    systemPrompt?: string;
+    maxTurns?: number;
+    errorRetryTurns?: number;
+    signal?: AbortSignal;
+    llmsContexts?: string[];
+    autoCompact?: boolean;
+    thinking?: ThinkingConfig;
+    temperature?: number;
+    responseFormat?: ResponseFormat;
+    onTextDelta?: (text: string) => Promise<void>;
+    onText?: (text: string) => Promise<void>;
+    onReasoning?: (text: string) => Promise<void>;
+    onStreamResult?: (result: StreamResult) => Promise<void>;
+    onChunk?: (chunk: any, requestId: string) => Promise<void>;
+    onToolUse?: (toolUse: ToolUse) => Promise<ToolUse>;
+    onToolResult?: (toolUse: ToolUse, toolResult: ToolResult, approved: boolean) => Promise<ToolResult>;
+    onTurn?: (turn: {
+        usage: Usage;
+        startTime: Date;
+        endTime: Date;
+    }) => Promise<void>;
+    onToolApprove?: (toolUse: ToolUse) => Promise<ToolApprovalResult>;
+    onMessage?: OnMessage;
+};
+export declare function runLoop(opts: RunLoopOpts): Promise<LoopResult>;
+export {};

package/dist/core/message.d.ts

@@ -0,0 +1,132 @@
+import type { ToolResult } from '../tools/tool';
+export type SystemMessage = {
+    role: 'system';
+    content: string;
+};
+export type TextPart = {
+    type: 'text';
+    text: string;
+};
+export type ImagePart = {
+    type: 'image';
+    data: string;
+    mimeType: string;
+};
+export type FilePart = {
+    type: 'file';
+    filename?: string;
+    data: string;
+    mimeType: string;
+};
+export type UserContent = string | Array<TextPart | ImagePart>;
+export type ToolUsePart = {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, any>;
+    displayName?: string;
+    description?: string;
+};
+export type ReasoningPart = {
+    type: 'reasoning';
+    text: string;
+};
+export type AssistantContent = string | Array<TextPart | ReasoningPart | ToolUsePart>;
+export type AssistantMessage = {
+    role: 'assistant';
+    content: AssistantContent;
+    text: string;
+    model: string;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+        cache_read_input_tokens?: number;
+        cache_creation_input_tokens?: number;
+    };
+};
+export type UserMessage = {
+    role: 'user';
+    content: UserContent;
+    hidden?: boolean;
+};
+export type ToolMessage = {
+    role: 'user';
+    content: ToolContent;
+};
+export type ToolMessage2 = {
+    role: 'tool';
+    content: ToolResultPart2[];
+};
+export type ToolResultPart2 = {
+    type: 'tool-result';
+    toolCallId: string;
+    toolName: string;
+    input: Record<string, any>;
+    result: ToolResult;
+    agentId?: string;
+    agentType?: string;
+};
+export type ToolContent = Array<ToolResultPart>;
+export type ToolResultPart = {
+    type: 'tool_result';
+    id: string;
+    name: string;
+    input: Record<string, any>;
+    result: ToolResult;
+    agentId?: string;
+    agentType?: string;
+};
+export type Message = SystemMessage | UserMessage | AssistantMessage | ToolMessage | ToolMessage2;
+export type NormalizedMessage = Message & {
+    type: 'message';
+    timestamp: string;
+    uuid: string;
+    parentUuid: string | null;
+    uiContent?: string;
+    metadata?: {
+        agentId?: string;
+        agentType?: string;
+        [key: string]: any;
+    };
+};
+export type SDKSystemMessage = {
+    type: 'system';
+    subtype: 'init';
+    sessionId: string;
+    model: string;
+    cwd: string;
+    tools: string[];
+};
+export type SDKResultMessage = {
+    type: 'result';
+    subtype: 'success' | 'error';
+    isError: boolean;
+    content: string;
+    sessionId: string;
+    __result?: any;
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+};
+export declare function toolResultPart2ToToolResultPart(part: ToolResultPart2): ToolResultPart;
+export declare function createToolResultPart2(toolCallId: string, toolName: string, input: Record<string, any>, result: ToolResult): ToolResultPart2;
+export declare function createUserMessage(content: string, parentUuid: string | null): NormalizedMessage;
+export declare function isToolResultMessage(message: Message): boolean;
+export declare function isCanceledMessage(message: Message): boolean;
+export declare function isUserTextMessage(message: Message): boolean;
+export declare function isUserBashCommandMessage(message: Message): boolean;
+export declare function isUserBashOutputMessage(message: Message): boolean;
+export declare function getMessageText(message: Message): string;
+/**
+ * Finds tool uses in the last assistant message that don't have corresponding tool results.
+ * This is useful for identifying incomplete tool executions, such as when a session is canceled
+ * before all tools have finished executing.
+ *
+ * @param messages - Array of normalized messages to analyze
+ * @returns Object containing the assistant message and incomplete tool uses, or null if none found
+ */
+export declare function findIncompleteToolUses(messages: NormalizedMessage[]): {
+    assistantMessage: NormalizedMessage;
+    incompleteToolUses: ToolUsePart[];
+} | null;