oricore 1.0.0

package/dist/tools/tools/todo.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+declare const TodoItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        pending: "pending";
+        in_progress: "in_progress";
+    }>;
+    priority: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+}, z.core.$strip>;
+export type TodoItem = z.infer<typeof TodoItemSchema>;
+export declare function createTodoTool(opts: {
+    filePath: string;
+}): {
+    todoWriteTool: import("../tool").Tool<z.ZodObject<{
+        todos: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            content: z.ZodString;
+            status: z.ZodEnum<{
+                completed: "completed";
+                pending: "pending";
+                in_progress: "in_progress";
+            }>;
+            priority: z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+};
+export {};

package/dist/tools/tools/write.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export declare function createWriteTool(opts: {
+    cwd: string;
+}): import("../tool").Tool<z.ZodObject<{
+    file_path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>>;

package/dist/utils/apiKeyRotation.d.ts

@@ -0,0 +1,2 @@
+export declare function rotateApiKey(apiKey: string): string;
+export declare function resetRotationIndex(): void;

package/dist/utils/applyEdit.d.ts

@@ -0,0 +1,17 @@
+export interface Edit {
+    old_string: string;
+    new_string: string;
+    replace_all?: boolean;
+}
+export interface Hunk {
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    lines: string[];
+}
+export declare function applyEdits(cwd: string, filePath: string, edits: Edit[]): {
+    patch: any;
+    updatedFile: string;
+    startLineNumber: number;
+};

package/dist/utils/background-detection.d.ts

@@ -0,0 +1,2 @@
+export declare function getCommandRoot(command: string): string | undefined;
+export declare function shouldRunInBackground(command: string, elapsedMs: number, hasOutput: boolean, isCommandCompleted: boolean, userRequested?: boolean): boolean;

package/dist/utils/dotenv.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Load .env file from the specified directory
+ * Searches for .env files in the following order:
+ * 1. .env.local
+ * 2. .env
+ *
+ * @param cwd - Current working directory
+ */
+export declare function loadEnvFile(cwd: string): void;

package/dist/utils/env.d.ts

@@ -0,0 +1,6 @@
+export declare function getEnv(): Promise<{
+    hasInternetAccess: boolean;
+    platform: string;
+    nodeVersion: string;
+    terminal: string | null;
+}>;

package/dist/utils/error.d.ts

@@ -0,0 +1,11 @@
+export declare function getErrorMessage(error: unknown): string;
+export declare class MaxFileReadLengthExceededError extends Error {
+    readonly maxFileLength: number;
+    readonly fileLength: number;
+    constructor(fileLength: number, maxFileLength: number);
+}
+export declare class MaxFileReadTokenExceededError extends Error {
+    readonly maxTokens: number;
+    readonly tokenCount: number;
+    constructor(tokenCount: number, maxTokens: number);
+}

package/dist/utils/execFileNoThrow.d.ts

@@ -0,0 +1,8 @@
+/**
+ * execFile, but always resolves (never throws)
+ */
+export declare function execFileNoThrow(cwd: string, file: string, args: string[], abortSignal?: AbortSignal, timeout?: number, preserveOutputOnError?: boolean): Promise<{
+    stdout: string;
+    stderr: string;
+    code: number;
+}>;

package/dist/utils/files.d.ts

@@ -0,0 +1,10 @@
+export interface FileItem {
+    path: string;
+    type: 'file' | 'directory';
+    name: string;
+}
+export declare function getFiles(opts: {
+    cwd: string;
+    maxSize: number;
+    query: string;
+}): Promise<FileItem[]>;

package/dist/utils/git.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Check if git is installed and available in PATH
+ */
+export declare function isGitInstalled(): Promise<boolean>;
+/**
+ * Check if the given directory is inside a git repository
+ */
+export declare function isGitRepository(cwd: string): Promise<boolean>;
+/**
+ * Check if git user name and email are configured
+ */
+export declare function isGitUserConfigured(cwd: string): Promise<{
+    name: boolean;
+    email: boolean;
+}>;
+/**
+ * Check if there are uncommitted changes (staged or unstaged)
+ */
+export declare function hasUncommittedChanges(cwd: string): Promise<boolean>;
+/**
+ * Get list of unstaged files with their status
+ * Returns files that have changes not yet staged (working tree changes)
+ */
+export declare function getUnstagedFiles(cwd: string): Promise<Array<{
+    status: string;
+    file: string;
+}>>;
+/**
+ * Check if any remote is configured
+ */
+export declare function hasRemote(cwd: string): Promise<boolean>;
+/**
+ * Check if origin remote is configured
+ */
+export declare function hasOriginRemote(cwd: string): Promise<boolean>;
+/**
+ * Check if a branch exists
+ */
+export declare function branchExists(cwd: string, branchName: string): Promise<boolean>;
+/**
+ * Get recent commit messages
+ */
+export declare function getRecentCommitMessages(cwd: string, count?: number): Promise<string>;
+/**
+ * Stage all changes
+ */
+export declare function stageAll(cwd: string): Promise<void>;
+/**
+ * Commit staged changes with a message
+ * @param cwd - Working directory
+ * @param message - Commit message
+ * @param skipHooks - Skip pre-commit hooks
+ * @param onOutput - Optional callback for streaming output
+ */
+export declare function gitCommit(cwd: string, message: string, skipHooks?: boolean, onOutput?: (line: string, stream: 'stdout' | 'stderr') => void): Promise<void>;
+/**
+ * Push changes to remote
+ * @param cwd - Working directory
+ * @param onOutput - Optional callback for streaming output
+ */
+export declare function gitPush(cwd: string, onOutput?: (line: string, stream: 'stdout' | 'stderr') => void): Promise<void>;
+/**
+ * Create and checkout a new branch
+ */
+export declare function createAndCheckoutBranch(cwd: string, branchName: string): Promise<void>;
+export declare function getGitStatus(opts: {
+    cwd: string;
+}): Promise<{
+    branch: string;
+    mainBranch: string;
+    status: string;
+    log: string;
+    author: string;
+    authorLog: string;
+} | null>;
+export declare function getLlmGitStatus(status: Awaited<ReturnType<typeof getGitStatus>>): Promise<string | null>;
+/**
+ * Get remote origin URL
+ */
+export declare function getGitRemoteUrl(cwd: string): Promise<string | null>;
+/**
+ * Get default branch from remote
+ */
+export declare function getDefaultBranch(cwd: string): Promise<string | null>;
+/**
+ * Check sync status with remote
+ */
+export declare function getGitSyncStatus(cwd: string): Promise<'synced' | 'ahead' | 'behind' | 'diverged' | 'unknown'>;
+/**
+ * Get current commit hash
+ */
+export declare function getCurrentCommit(cwd: string): Promise<string>;
+/**
+ * Get list of pending changes
+ */
+export declare function getPendingChanges(cwd: string): Promise<string[]>;
+/**
+ * Get staged file list with status
+ */
+export declare function getStagedFileList(cwd: string): Promise<string>;
+/**
+ * Validate git repository URL format
+ */
+export declare function validateGitUrl(url: string): boolean;
+/**
+ * Sanitize git URL to prevent command injection
+ */
+export declare function sanitizeGitUrl(url: string): string;
+/**
+ * Validate destination path security
+ */
+export declare function validateDestinationPath(destination: string): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Extract repository name from git URL
+ */
+export declare function extractRepoName(url: string): string;
+/**
+ * Parse git clone progress output
+ */
+export interface GitCloneProgress {
+    percent: number;
+    message: string;
+}
+export declare class GitCloneProgressParser {
+    private currentStage;
+    private stageProgress;
+    private lastOverallPercent;
+    parse(output: string): GitCloneProgress | null;
+}
+/**
+ * Clone repository options
+ */
+export interface CloneRepositoryOptions {
+    url: string;
+    destination: string;
+    onProgress?: (progress: GitCloneProgress) => void;
+    signal?: AbortSignal;
+    timeoutMinutes?: number;
+}
+/**
+ * Clone repository result
+ */
+export interface CloneRepositoryResult {
+    success: boolean;
+    clonePath?: string;
+    repoName?: string;
+    error?: string;
+    errorCode?: 'CANCELLED' | 'SSH_AUTH_FAILED' | 'AUTH_REQUIRED' | 'NETWORK_ERROR' | 'REPO_NOT_FOUND' | 'TIMEOUT' | 'GIT_NOT_INSTALLED' | 'INVALID_URL' | 'DIR_EXISTS' | 'UNKNOWN';
+    needsCredentials?: boolean;
+}
+/**
+ * Clone a git repository
+ */
+export declare function cloneRepository(options: CloneRepositoryOptions): Promise<CloneRepositoryResult>;
+/**
+ * Get the staged diff while handling large files
+ * - Excludes common lockfiles and large file types
+ * - Limits diff size to prevent context overflow
+ */
+export declare function getStagedDiff(cwd: string): Promise<string>;

package/dist/utils/ide.d.ts

@@ -0,0 +1,27 @@
+export declare const vscode_extension_id = "your-org.oricore-assistant";
+export interface PlatformInfo {
+    terminal: string | null;
+    platform: string;
+}
+export interface CommandResult {
+    code: number;
+    stdout?: string;
+    stderr?: string;
+    error?: string;
+}
+export interface InstallationResult {
+    installed: boolean;
+    error: string | null;
+    installedVersion: string | null;
+}
+export declare function isVSCodeBased(terminal: string | null): boolean;
+export declare function isJetBrainsBased(terminal: string | null): boolean;
+export declare function getMacOSVSCodePath(): string | null;
+export declare function getVSCodeCommand(terminal: string | null): string | null;
+export declare function isExtensionInstalled(platformInfo: PlatformInfo): Promise<boolean>;
+export declare function installExtension(platformInfo: PlatformInfo, vsixPath: string): Promise<string | null>;
+export declare function getCleanEnvironment(platform: string): NodeJS.ProcessEnv;
+export declare function getExtensionVersion(): string;
+export declare function attemptInstallation(platformInfo: PlatformInfo, vsixPath: string): Promise<InstallationResult>;
+export declare function getIDEDisplayName(terminal: string): string;
+export declare function isRunningInSupportedIDE(platformInfo: PlatformInfo): boolean;

package/dist/utils/ignore.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Checks if a file or directory should be ignored based on ignore rules
+ */
+export declare function isIgnored(filePath: string, rootPath: string, productNames?: string[]): boolean;
+export declare function parseProductIgnorePatterns(rootPath: string, productNames: string[]): string[];
+export declare function matchesAnyPattern(filePath: string, patterns: string[]): boolean;

package/dist/utils/isLocal.d.ts

@@ -0,0 +1 @@
+export declare function isLocal(): boolean;

package/dist/utils/language.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if the given language is English or English-related.
+ */
+export declare function isEnglish(language: string): boolean;
+/**
+ * Returns the language instruction string for prompts.
+ * Returns empty string if the language is English.
+ */
+export declare function getLanguageInstruction(language: string, format?: 'communicate' | 'respond'): string;

package/dist/utils/list.d.ts

@@ -0,0 +1,20 @@
+export declare const MAX_FILES = 1000;
+export declare const TRUNCATED_MESSAGE = "There are more than 1000 files in the repository. Use the LS tool (passing a specific path), Bash tool, and other tools to explore nested directories. The first 1000 files and directories are included below:\n\n";
+export declare function listDirectory(initialPath: string, cwd: string, maxFiles?: number): string[];
+export declare function listRootDirectory(rootPath: string): string[];
+type TreeNode = {
+    name: string;
+    path: string;
+    type: 'file' | 'directory';
+    children?: TreeNode[];
+};
+export declare function createFileTree(sortedPaths: string[]): TreeNode[];
+/**
+ * eg.
+ * - src/
+ *   - index.ts
+ *   - utils/
+ *     - file.ts
+ */
+export declare function printTree(cwd: string, tree: TreeNode[], level?: number, prefix?: string): string;
+export {};

package/dist/utils/mergeSystemMessagesMiddleware.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageModelMiddleware } from 'ai';
+export declare const mergeSystemMessagesMiddleware: LanguageModelMiddleware;

package/dist/utils/messageNormalization.d.ts

@@ -0,0 +1,22 @@
+import type { NormalizedMessage } from '../core/message';
+/**
+ * Normalizes messages for compacting by filtering out tool-related content
+ * while preserving the conversational flow and essential information.
+ *
+ * This function transforms tool calls and results into human-readable summaries
+ * to make the conversation history suitable for compression without losing
+ * important context about what operations were performed.
+ *
+ * For assistant messages:
+ * - Removes tool_use parts
+ * - Keeps text and reasoning parts
+ * - If no text content exists, converts reasoning to text for readability
+ * - If no content remains, uses a default placeholder
+ *
+ * For tool messages:
+ * - Converts to user messages with tool execution summaries
+ *
+ * @param messages - Array of normalized messages to process
+ * @returns Array of normalized messages with tool content converted to summaries
+ */
+export declare function normalizeMessagesForCompact(messages: NormalizedMessage[]): NormalizedMessage[];

package/dist/utils/path.d.ts

@@ -0,0 +1,34 @@
+export declare function relativeToHome(p: string): string;
+export type PathValidationResult = {
+    resultType: 'success';
+    absolutePath: string;
+} | {
+    resultType: 'emptyPath';
+} | {
+    resultType: 'pathNotFound';
+    directoryPath: string;
+    absolutePath: string;
+} | {
+    resultType: 'notADirectory';
+    directoryPath: string;
+    absolutePath: string;
+} | {
+    resultType: 'alreadyInWorkingDirectory';
+    directoryPath: string;
+    workingDir: string;
+};
+/**
+ * Check if childPath is within parentPath
+ */
+export declare function isPathWithin(childPath: string, parentPath: string): boolean;
+/**
+ * Validate directory path
+ * @param inputPath Path input by user
+ * @param existingDirectories List of existing working directories (including cwd)
+ * @returns Validation result
+ */
+export declare function validateDirectoryPath(inputPath: string, existingDirectories: string[]): PathValidationResult;
+/**
+ * Format validation result into user-friendly message
+ */
+export declare function formatValidationMessage(result: PathValidationResult): string;

package/dist/utils/prependSystemMessageMiddleware.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageModelMiddleware } from 'ai';
+export declare const prependSystemMessageMiddleware: LanguageModelMiddleware;

package/dist/utils/project.d.ts

@@ -0,0 +1 @@
+export declare function isProjectDirectory(cwd: string): boolean;

package/dist/utils/proxy.d.ts

@@ -0,0 +1,18 @@
+/**
+ * HTTP Proxy utilities for AI model providers
+ * Handles proxy configuration and custom fetch implementation
+ */
+/**
+ * Create a custom fetch function that uses the specified proxy
+ * This wraps undici's fetch with the ProxyAgent
+ *
+ * Why needed: Bun's native fetch doesn't support HTTP_PROXY env vars,
+ * so we use undici's fetch with ProxyAgent to handle proxy requests
+ *
+ * @param proxyUrl - Proxy URL (e.g., http://127.0.0.1:7890 or socks5://127.0.0.1:1080)
+ * @returns A fetch-compatible function that routes requests through the configured proxy
+ * @example
+ * const proxyFetch = createProxyFetch('http://127.0.0.1:7890');
+ * await proxyFetch('https://api.openai.com/v1/models');
+ */
+export declare function createProxyFetch(proxyUrl: string): typeof fetch;

package/dist/utils/randomUUID.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generate a random UUID v4 compatible string
+ * Compatible with Node.js 18+ without using crypto module
+ */
+export declare function randomUUID(): string;

package/dist/utils/renderSessionMarkdown.d.ts

@@ -0,0 +1,10 @@
+import type { NormalizedMessage } from '../core/message';
+export declare function renderSessionMarkdown(opts: {
+    sessionId: string;
+    title: string;
+    projectPath: string;
+    model: string | null;
+    messages: NormalizedMessage[];
+    createdAt: Date;
+    updatedAt: Date;
+}): string;

package/dist/utils/ripgrep.d.ts

@@ -0,0 +1,16 @@
+export interface RipGrepResult {
+    success: boolean;
+    lines: string[];
+    exitCode: number | null;
+    stderr: string;
+}
+export declare function ripgrepPath(): string;
+export declare function ripGrep(args: string[], target: string): Promise<RipGrepResult>;
+export interface SearchFilesResult {
+    success: boolean;
+    data: {
+        paths: string[];
+        truncated: boolean;
+    };
+}
+export declare function searchFiles(cwd: string, query: string, maxResults?: number): Promise<SearchFilesResult>;

package/dist/utils/safeFrontMatter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Safely parse frontmatter from markdown content with automatic error recovery
+ * Handles common YAML issues like unquoted colons in values
+ * @param content - The markdown content with frontmatter
+ * @param filePath - Optional file path for better error messages
+ * @returns Parsed frontmatter attributes and body
+ */
+export declare function safeFrontMatter<T = Record<string, string>>(content: string, filePath?: string): {
+    attributes: T;
+    body: string;
+};

package/dist/utils/safeParseJson.d.ts

@@ -0,0 +1 @@
+export declare function safeParseJson(json: string): any;

package/dist/utils/safeStringify.d.ts

@@ -0,0 +1 @@
+export declare function safeStringify(obj: any, fallbackMessage?: string): string;

package/dist/utils/sanitizeAIResponse.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Utilities for sanitizing AI text responses by removing formatting artifacts.
+ * Composes: stripThinkTags → stripCodeBlocks → stripInlineCode → trim
+ */
+/**
+ * Removes <think>...</think> tags from AI responses.
+ * Handles nested tags with non-greedy matching.
+ */
+export declare function stripThinkTags(text: string): string;
+/**
+ * Removes markdown code block formatting (```lang\n...\n```).
+ * Only strips if the entire response is wrapped in a single code block.
+ * Preserves multi-block responses.
+ * Trims input to handle leading/trailing whitespace before matching.
+ */
+export declare function stripCodeBlocks(text: string): string;
+/**
+ * Removes inline code formatting when entire string is wrapped in backticks.
+ * Preserves shell backticks within commands (e.g., echo `date`).
+ * Only removes when exactly 2 backticks wrap the entire string.
+ */
+export declare function stripInlineCode(text: string): string;
+/**
+ * Main sanitization function that composes all sanitization steps.
+ * Order: stripThinkTags → stripCodeBlocks → stripInlineCode → trim
+ *
+ * @param text - Raw AI response text
+ * @returns Cleaned text with formatting removed
+ */
+export declare function sanitizeAIResponse(text: string): string;

package/dist/utils/setTerminalTitle.d.ts

@@ -0,0 +1 @@
+export declare function setTerminalTitle(title: string): void;

package/dist/utils/shell-execution.d.ts

@@ -0,0 +1,44 @@
+export interface ShellExecutionResult {
+    /** The raw, unprocessed output buffer. */
+    rawOutput: Buffer;
+    /** The combined, decoded stdout and stderr as a string. */
+    output: string;
+    /** The decoded stdout as a string. */
+    stdout: string;
+    /** The decoded stderr as a string. */
+    stderr: string;
+    /** The process exit code, or null if terminated by a signal. */
+    exitCode: number | null;
+    /** The signal that terminated the process, if any. */
+    signal: NodeJS.Signals | null;
+    /** An error object if the process failed to spawn. */
+    error: Error | null;
+    /** The process ID of the spawned shell. */
+    pid: number | undefined;
+    /** Whether the execution was cancelled due to timeout or manual termination. */
+    cancelled: boolean;
+}
+export interface ShellExecutionHandle {
+    /** The process ID of the spawned shell. */
+    pid: number | undefined;
+    /** A promise that resolves with the complete execution result. */
+    result: Promise<ShellExecutionResult>;
+}
+export type ShellOutputEvent = {
+    /** The event contains a chunk of output data. */
+    type: 'data';
+    /** The stream from which the data originated. */
+    stream: 'stdout' | 'stderr';
+    /** The decoded string chunk. */
+    chunk: string;
+} | {
+    /** Signals that the output stream has been identified as binary. */
+    type: 'binary_detected';
+} | {
+    /** Provides progress updates for a binary stream. */
+    type: 'binary_progress';
+    /** The total number of bytes received so far. */
+    bytesReceived: number;
+};
+export declare function shellExecute(commandToExecute: string, cwd: string, timeout: number, onOutputEvent?: (event: ShellOutputEvent) => void): ShellExecutionHandle;
+export declare function isBinary(data: Buffer | null | undefined, sampleSize?: number): boolean;

package/dist/utils/string.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts a kebab-case string to Title Case.
+ * Examples:
+ * - "foo-bar" → "Foo Bar"
+ * - "review" → "Review"
+ * - "multi-word-command" → "Multi Word Command"
+ */
+export declare function kebabToTitleCase(kebabString: string): string;

package/dist/utils/symbols.d.ts

@@ -0,0 +1,14 @@
+export declare const symbols: {
+    checkboxOn: string;
+    checkboxOff: string;
+    tick: string;
+    cross: string;
+    pointer: string;
+    arrowRight: string;
+    pointerSmall: string;
+    line: string;
+    bullet: string;
+    info: string;
+    warning: string;
+    arrowDown: string;
+};

package/dist/utils/system-encoding.d.ts

@@ -0,0 +1,40 @@
+type SystemEncoding = string | null;
+/**
+ * Reset the encoding cache - useful for testing or when system configuration changes
+ */
+export declare function resetEncodingCache(): void;
+/**
+ * Returns the system encoding with caching and fallback to buffer detection.
+ * Handles concurrent calls gracefully and provides robust error recovery.
+ *
+ * @param buffer - Buffer to analyze if system detection fails
+ * @returns The detected encoding or 'utf-8' as ultimate fallback
+ */
+export declare function getCachedEncodingForBuffer(buffer: Buffer): Promise<string>;
+/**
+ * Synchronous version for backward compatibility
+ * Note: This may block on first call if system encoding hasn't been cached
+ */
+export declare function getCachedEncodingForBufferSync(buffer: Buffer): string;
+/**
+ * Detects system encoding based on platform with improved error handling
+ *
+ * @returns The system encoding or null if detection fails
+ */
+export declare function getSystemEncodingSync(): SystemEncoding;
+/**
+ * Convert Windows code page to encoding with comprehensive mapping
+ *
+ * @param cp - Windows code page number
+ * @returns Corresponding encoding name or null if unmapped
+ */
+export declare function windowsCodePageToEncoding(cp: number): SystemEncoding;
+/**
+ * Detect encoding from buffer using chardet with enhanced error handling
+ *
+ * @param buffer - Buffer to analyze
+ * @returns Detected encoding in lowercase or null if detection fails
+ */
+export declare function detectEncodingFromBuffer(buffer: Buffer): SystemEncoding;
+export declare const getSystemEncoding: typeof getSystemEncodingSync;
+export {};

package/dist/utils/tokenCounter.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Count tokens in a text string using gpt-tokenizer
+ * Falls back to simple estimation if encoding fails
+ *
+ * @param text - The text to count tokens for
+ * @returns The number of tokens
+ */
+export declare function countTokens(text: string): number;

package/dist/utils/username.d.ts

@@ -0,0 +1 @@
+export declare function getUsername(): string | undefined;