oricore 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2025 AI Code Engine
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,199 @@
+<div align="center">
+
+# OriCore
+
+**A powerful, standalone AI coding engine with multi-model support, tool calling, and extensible architecture**
+
+[![npm version](https://badge.fury.io/js/oricore.svg)](https://www.npmjs.com/package/oricore)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+</div>
+
+## Features
+
+- 🤖 **Multi-Model Support**: OpenAI, Anthropic, Google, DeepSeek, and 40+ providers
+- 🛠️ **Rich Tool System**: read, write, edit, grep, glob, fetch, and more
+- 🧠 **Interaction Modes**: brainstorm, plan, review, debug, and default modes
+- 🔌 **MCP Integration**: Extensible via Model Context Protocol
+- 🎯 **Agent System**: Built-in agents for complex tasks
+- 💬 **Interactive**: Q&A tool for user interaction
+- 📦 **Zero Configuration**: Works out of the box with sensible defaults
+- 🔧 **Fully Typed**: Complete TypeScript support
+
+## Installation
+
+```bash
+npm install oricore
+```
+
+```bash
+# Using pnpm
+pnpm add oricore
+
+# Using bun
+bun add oricore
+```
+
+## Quick Start
+
+```typescript
+import { createEngine } from 'oricore';
+
+const engine = createEngine({
+  productName: 'MyApp',
+  version: '1.0.0',
+});
+
+await engine.initialize({
+  model: 'openai/gpt-4o',
+});
+
+const result = await engine.sendMessage({
+  message: 'Create a TypeScript function to calculate fibonacci',
+  write: true,
+});
+
+console.log(result.data.text);
+```
+
+## Usage
+
+### Basic Chat
+
+```typescript
+const answer = await engine.ask('What is TypeScript?');
+```
+
+### Multi-Turn Conversation
+
+```typescript
+const result = await engine.sendMessage({
+  message: 'Create a user class',
+  write: true,
+  maxTurns: 50,
+});
+```
+
+### Brainstorming Mode
+
+```typescript
+engine.setMode('brainstorm');
+
+const result = await engine.sendMessageWithMode(
+  'I want to build a task management app',
+  {
+    onToolApprove: async (toolUse) => {
+      if (toolUse.name === 'askUserQuestion') {
+        const questions = toolUse.params.questions;
+        // Collect user answers
+        const answers = await collectAnswers(questions);
+        return {
+          approved: true,
+          params: { ...toolUse.params, answers },
+        };
+      }
+      return { approved: true };
+    },
+  }
+);
+```
+
+### Custom Mode
+
+```typescript
+engine.registerMode({
+  id: 'code-reviewer',
+  name: 'Code Reviewer',
+  config: {
+    systemPrompt: 'You are a code reviewer...',
+    write: false,
+    askUserQuestion: false,
+  },
+});
+
+engine.setMode('code-reviewer');
+```
+
+## Configuration
+
+### Environment Variables
+
+```bash
+# OpenAI
+export OPENAI_API_KEY=sk-...
+export OPENAI_API_BASE=https://api.openai.com/v1
+
+# Anthropic
+export ANTHROPIC_API_KEY=sk-ant-...
+
+# Google
+export GOOGLE_API_KEY=...
+
+# DeepSeek
+export DEEPSEEK_API_KEY=...
+```
+
+### Initialize with Config
+
+```typescript
+await engine.initialize({
+  model: 'openai/gpt-4o',
+  provider: {
+    openai: {
+      apiKey: 'sk-...',
+      baseURL: 'https://api.openai.com/v1'
+    }
+  }
+});
+```
+
+## API
+
+### Engine Class
+
+```typescript
+class Engine {
+  constructor(options: EngineOptions)
+  async initialize(config: EngineConfig): Promise<void>
+  async sendMessage(options: SendMessageOptions): Promise<LoopResult>
+  async ask(message: string): Promise<string>
+  async createSession(options?: SessionOptions): Promise<Session>
+  setMode(mode: ModeType): void
+  sendMessageWithMode(message: string, options?: Partial<SendMessageOptions>): Promise<LoopResult>
+  getContext(): Context
+  getMessageBus(): MessageBus
+  async shutdown(): Promise<void>
+}
+```
+
+### Modes
+
+- `default` - General purpose coding assistant
+- `brainstorm` - Interactive design and ideation
+- `plan` - Create implementation plans
+- `review` - Code review and analysis
+- `debug` - Troubleshooting and debugging
+
+## Examples
+
+See the `examples/` directory for more examples:
+
+- `basic.ts` - Basic usage
+- `modes.ts` - Using different modes
+- `streaming.ts` - Streaming responses
+
+## Documentation
+
+For more detailed documentation, please visit the [USAGE.md](./USAGE.md) file.
+
+## License
+
+MIT © [lyw405](https://github.com/lyw405)
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Support
+
+If you have any questions or issues, please [open an issue](https://github.com/lyw405/oricore/issues) on GitHub.

package/dist/agent/agent/agentManager.d.ts

@@ -0,0 +1,38 @@
+import type { Context } from '../../core/context';
+import type { NormalizedMessage } from '../../core/message';
+import type { ApprovalCategory, Tool, ToolApprovalResult, ToolUse } from '../../tools/tool';
+import type { AgentDefinition, AgentExecutionResult, AgentLoadError, TaskToolInput } from './types';
+export declare class AgentManager {
+    private agents;
+    private context;
+    private errors;
+    constructor(opts: {
+        context: Context;
+    });
+    private registerBuiltinAgents;
+    registerAgent(definition: AgentDefinition): void;
+    isAgentEnabled(agent: AgentDefinition): boolean;
+    getAgent(agentType: string): AgentDefinition | undefined;
+    getAllAgents(): AgentDefinition[];
+    getAgentTypes(): string[];
+    executeTask(input: TaskToolInput, context: {
+        tools: Tool[];
+        cwd: string;
+        signal?: AbortSignal;
+        parentSessionId?: string;
+        forkContextMessages?: NormalizedMessage[];
+        onMessage?: (message: NormalizedMessage, agentId: string, model: string) => void | Promise<void>;
+        onToolApprove?: (opts: {
+            toolUse: ToolUse;
+            category?: ApprovalCategory;
+        }) => Promise<boolean | ToolApprovalResult>;
+    }): Promise<AgentExecutionResult>;
+    getAgentDescriptions(): string;
+    loadAgents(): Promise<void>;
+    private loadAgentsFromPlugins;
+    getErrors(): AgentLoadError[];
+    private loadAgentsFromDirectory;
+    private loadAgentFile;
+    private convertToolNames;
+    private parseAgentFile;
+}

package/dist/agent/agent/builtin/common.d.ts

@@ -0,0 +1,5 @@
+export declare const TASK_TOOL_NAME = "task";
+export declare const EDIT_TOOLS: string[];
+export declare function buildDisallowedTools(...toolGroups: string[][]): string[];
+export declare const CONTEXT_NOTES: string;
+export declare const THOROUGHNESS_LEVELS: string;

package/dist/agent/agent/builtin/explore.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from '../../../core/context';
+import { type AgentDefinition } from '../types';
+export declare function createExploreAgent(opts: {
+    context: Context;
+}): AgentDefinition;

package/dist/agent/agent/builtin/general-purpose.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from '../../../core/context';
+import { type AgentDefinition } from '../types';
+export declare function createGeneralPurposeAgent(opts: {
+    context: Context;
+}): AgentDefinition;

package/dist/agent/agent/builtin/index.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from '../../../core/context';
+import type { AgentDefinition } from '../types';
+export declare function getBuiltinAgents(opts: {
+    context: Context;
+}): AgentDefinition[];

package/dist/agent/agent/executor.d.ts

@@ -0,0 +1,2 @@
+import type { AgentExecuteOptions, AgentExecutionResult } from './types';
+export declare function executeAgent(options: AgentExecuteOptions): Promise<AgentExecutionResult>;

package/dist/agent/agent/types.d.ts

@@ -0,0 +1,98 @@
+import type { Context } from '../../core/context';
+import type { NormalizedMessage } from '../../core/message';
+import type { ApprovalCategory, Tool, ToolApprovalResult, ToolUse } from '../../tools/tool';
+export interface AgentDefinition {
+    agentType: string;
+    whenToUse: string;
+    systemPrompt: string;
+    model: string;
+    source: AgentSource;
+    tools?: string[];
+    disallowedTools?: string[];
+    forkContext?: boolean;
+    color?: string;
+    path?: string;
+    /**
+     * Controls whether the agent is available for use.
+     * - boolean: Static toggle (default: true)
+     * - function: Dynamic check based on context
+     */
+    isEnabled?: boolean | ((context: Context) => boolean);
+}
+export type PluginAgentDefinition = Omit<AgentDefinition, 'source' | 'model'> & {
+    model?: string;
+};
+export interface TaskToolInput {
+    description: string;
+    prompt: string;
+    subagent_type: string;
+    model?: string;
+    resume?: string;
+}
+export interface AgentExecutionResult {
+    status: 'completed' | 'failed';
+    agentId: string;
+    content: string;
+    totalToolCalls: number;
+    totalDuration: number;
+    model?: string;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+export interface AgentExecuteOptions {
+    definition: AgentDefinition;
+    prompt: string;
+    tools: Tool[];
+    context: Context;
+    model?: string;
+    forkContextMessages?: NormalizedMessage[];
+    cwd: string;
+    signal?: AbortSignal;
+    resume?: string;
+    parentSessionId?: string;
+    onMessage?: (message: NormalizedMessage, agentId: string, model: string) => void | Promise<void>;
+    onToolApprove?: (opts: {
+        toolUse: ToolUse;
+        category?: ApprovalCategory;
+    }) => Promise<boolean | ToolApprovalResult>;
+}
+/**
+ * Real-time progress data for SubAgent execution
+ * Used to track and display SubAgent progress in the UI
+ */
+export interface AgentProgressData {
+    /** The tool use ID that triggered this SubAgent (e.g., "task-1") */
+    toolUseID: string;
+    /** Unique identifier for the SubAgent instance */
+    agentId: string;
+    /** The latest message produced by the SubAgent */
+    message: NormalizedMessage;
+    /** Timestamp when this progress update was created */
+    timestamp: number;
+}
+/**
+ * Event payload for agent.progress events sent through MessageBus
+ */
+export interface AgentProgressEvent {
+    /** Session ID of the parent agent */
+    sessionId: string;
+    /** Current working directory */
+    cwd: string;
+    /** Progress data payload */
+    progressData: AgentProgressData;
+}
+export declare enum AgentSource {
+    BuiltIn = "built-in",
+    Plugin = "plugin",
+    User = "user",
+    ProjectClaude = "project-claude",
+    Project = "project",
+    GlobalClaude = "global-claude",
+    Global = "global"
+}
+export interface AgentLoadError {
+    path: string;
+    message: string;
+}

package/dist/api/engine.d.ts

@@ -0,0 +1,213 @@
+/**
+ * Engine API
+ *
+ * Main entry point for the OriCore package.
+ * Provides a high-level API for AI-powered coding assistance.
+ */
+import type { Context } from '../core/context';
+import type { ProviderConfig } from '../core/config';
+import { MessageBus } from '../communication/messageBus';
+import type { PlatformAdapter } from '../platform';
+import type { Session } from '../session/session';
+import { type LoopResult } from '../core/loop';
+import type { NormalizedMessage } from '../core/message';
+import type { ToolUse, ToolResult, ToolApprovalResult } from '../tools/tool';
+import { type Mode, type ModeType } from '../modes';
+/**
+ * Engine initialization options
+ */
+export interface EngineOptions {
+    /** Product name (e.g., "AI Engine") */
+    productName: string;
+    /** ASCII art banner for display */
+    productASCIIArt?: string;
+    /** Version string */
+    version: string;
+    /** Current working directory */
+    cwd?: string;
+    /** Fetch implementation (optional, uses globalThis.fetch by default) */
+    fetch?: typeof globalThis.fetch;
+    /** Platform implementation (defaults to Node.js) */
+    platform?: PlatformAdapter;
+    /** Message bus for event communication */
+    messageBus?: MessageBus;
+}
+/**
+ * Engine configuration
+ */
+export interface EngineConfig {
+    /** Model to use for AI responses */
+    model?: string;
+    /** Model for planning mode */
+    planModel?: string;
+    /** Approval mode for tool usage */
+    approvalMode?: 'default' | 'autoEdit' | 'yolo';
+    /** System prompt override */
+    systemPrompt?: string;
+    /** Additional system prompt */
+    appendSystemPrompt?: string;
+    /** Language for responses */
+    language?: string;
+    /** MCP servers configuration */
+    mcpServers?: Record<string, any>;
+    /** Tools configuration */
+    tools?: Record<string, boolean>;
+    /** Plugins to load */
+    plugins?: (string | any)[];
+    /** Provider configuration (custom API endpoints, keys, etc.) */
+    provider?: Record<string, ProviderConfig>;
+}
+/**
+ * Session creation options
+ */
+export interface SessionOptions {
+    /** Session ID (auto-generated if not provided) */
+    sessionId?: string;
+    /** Resume from existing session */
+    resume?: string;
+    /** Continue from latest session */
+    continue?: boolean;
+}
+/**
+ * Message sending options
+ */
+export interface SendMessageOptions {
+    /** Message content (string or message array) */
+    message: string | NormalizedMessage[];
+    /** Enable write tools (default: true) */
+    write?: boolean;
+    /** Enable todo tools (default: true) */
+    todo?: boolean;
+    /** Enable ask user question tool (default: false) */
+    askUserQuestion?: boolean;
+    /** Enable task/agent tool (default: false) */
+    task?: boolean;
+    /** Override model for this message */
+    model?: string;
+    /** Maximum turns (default: 50) */
+    maxTurns?: number;
+    /** Abort signal for cancellation */
+    signal?: AbortSignal;
+    /** Callback for text delta (streaming) */
+    onTextDelta?: (text: string) => Promise<void>;
+    /** Callback for complete text */
+    onText?: (text: string) => Promise<void>;
+    /** Callback for reasoning */
+    onReasoning?: (text: string) => Promise<void>;
+    /** Callback for tool use */
+    onToolUse?: (toolUse: ToolUse) => Promise<ToolUse>;
+    /** Callback for tool result */
+    onToolResult?: (toolUse: ToolUse, toolResult: ToolResult, approved: boolean) => Promise<ToolResult>;
+    /** Callback for tool approval (return false to deny) */
+    onToolApprove?: (toolUse: ToolUse) => Promise<ToolApprovalResult>;
+    /** Callback for turn completion */
+    onTurn?: (turn: any) => Promise<void>;
+}
+/**
+ * Main Engine class
+ *
+ * The Engine is the primary interface for interacting with the AI coding assistant.
+ * It manages initialization, configuration, and provides access to context.
+ */
+export declare class Engine {
+    private context;
+    private platform;
+    private messageBus;
+    private options;
+    private initialized;
+    private currentMode;
+    constructor(options: EngineOptions);
+    /**
+     * Initialize the engine with configuration
+     */
+    initialize(config?: EngineConfig): Promise<void>;
+    /**
+     * Create or resume a session
+     */
+    createSession(options?: SessionOptions): Promise<Session>;
+    /**
+     * Get the MessageBus for event communication
+     */
+    getMessageBus(): MessageBus;
+    /**
+     * Get the current context
+     */
+    getContext(): Context;
+    /**
+     * Shutdown the engine and cleanup resources
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Send a message to the AI and get a response
+     *
+     * This is the main method for interacting with the AI engine.
+     * It handles the full conversation loop including tool execution.
+     *
+     * @param options - Message sending options
+     * @returns Promise<LoopResult> - The result of the conversation loop
+     */
+    sendMessage(options: SendMessageOptions): Promise<LoopResult>;
+    /**
+     * Create a simple request-response interaction (single turn)
+     *
+     * This is a simplified version of sendMessage that returns just the text response.
+     * Tools are disabled by default for simple requests.
+     *
+     * @param message - The message to send
+     * @param options - Optional configuration
+     * @returns Promise<string> - The AI's text response
+     */
+    ask(message: string, options?: {
+        model?: string;
+        systemPrompt?: string;
+    }): Promise<string>;
+    /**
+     * Set the current interaction mode
+     *
+     * @param mode - The mode to set (e.g., 'brainstorm', 'plan', 'review')
+     */
+    setMode(mode: ModeType): void;
+    /**
+     * Get the current mode
+     */
+    getMode(): ModeType;
+    /**
+     * Get all available modes
+     */
+    getAvailableModes(): Mode[];
+    /**
+     * Register a custom mode
+     *
+     * @param mode - The mode to register
+     */
+    registerMode(mode: Mode): void;
+    /**
+     * Send a message using the current mode
+     *
+     * This is a convenience method that applies the current mode's configuration
+     *
+     * @param message - The message to send
+     * @param options - Optional overrides for this specific message
+     * @returns Promise<LoopResult> - The result of the conversation loop
+     */
+    sendMessageWithMode(message: string | NormalizedMessage[], options?: Partial<Omit<SendMessageOptions, 'message' | 'systemPrompt'>> & {
+        systemPrompt?: string;
+    }): Promise<LoopResult>;
+    /**
+     * Internal method to send message with custom system prompt
+     */
+    private _sendMessageWithSystemPrompt;
+    /**
+     * Generate a unique session ID
+     */
+    private generateSessionId;
+}
+/**
+ * Create a new Engine instance
+ */
+export declare function createEngine(options: EngineOptions): Engine;
+export type { Config, ApprovalMode } from '../core/config';
+export type { Session, SessionId } from '../session/session';
+export type { Tool, ToolUse, ToolResult } from '../tools/tool';
+export type { Message, NormalizedMessage, UserMessage, AssistantMessage } from '../core/message';
+export type { Plugin, PluginHookType } from '../core/plugin';

package/dist/communication/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Communication layer exports
+ */
+export { MessageBus, DirectTransport, type MessageId, type BaseMessage, type RequestMessage, type ResponseMessage, type EventMessage, type Message, type ConnectionState, type MessageTransport, type MessageHandler, type EventHandler, } from './messageBus';

package/dist/communication/messageBus.d.ts

@@ -0,0 +1,71 @@
+import EventEmitter from 'events';
+export type MessageId = string;
+export type BaseMessage = {
+    id: MessageId;
+    timestamp: number;
+};
+export type RequestMessage = BaseMessage & {
+    type: 'request';
+    method: string;
+    params: any;
+};
+export type ResponseMessage = BaseMessage & {
+    type: 'response';
+    result?: any;
+    error?: any;
+};
+export type EventMessage = BaseMessage & {
+    type: 'event';
+    event: string;
+    data: any;
+};
+export type Message = RequestMessage | ResponseMessage | EventMessage;
+export type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error' | 'closed';
+export interface MessageTransport {
+    send: (message: Message) => Promise<void>;
+    onMessage: (handler: (message: Message) => void) => void;
+    onError: (handler: (error: Error) => void) => void;
+    onClose: (handler: () => void) => void;
+    close: () => Promise<void>;
+    isConnected: () => boolean;
+}
+export declare class DirectTransport extends EventEmitter implements MessageTransport {
+    private peer?;
+    private state;
+    private messageBuffer;
+    constructor();
+    static createPair(): [DirectTransport, DirectTransport];
+    setPeer(peer: DirectTransport): void;
+    isConnected(): boolean;
+    onMessage(handler: (message: Message) => void): void;
+    onError(handler: (error: Error) => void): void;
+    onClose(handler: () => void): void;
+    send(message: Message): Promise<void>;
+    close(): Promise<void>;
+    private flushBuffer;
+    private receive;
+}
+export type MessageHandler = (data: any) => Promise<any>;
+export type EventHandler = (data: any) => void;
+export declare class MessageBus extends EventEmitter {
+    messageHandlers: Map<string, MessageHandler>;
+    private transport?;
+    private pendingRequests;
+    private eventHandlers;
+    constructor();
+    setTransport(transport: MessageTransport): void;
+    isConnected(): boolean;
+    request(method: string, params: any, options?: {
+        timeout?: number;
+    }): Promise<any>;
+    registerHandler(method: string, handler: MessageHandler): void;
+    unregisterHandler(method: string): void;
+    emitEvent(event: string, data: any): Promise<void>;
+    onEvent(event: string, handler: EventHandler): void;
+    offEvent(event: string, handler: EventHandler): void;
+    private handleIncomingMessage;
+    private handleRequest;
+    private handleResponse;
+    private handleEvent;
+    private sendResponse;
+}