oricore 1.0.0

package/src/utils/messageNormalization.ts

@@ -0,0 +1,168 @@
+import type {
+  NormalizedMessage,
+  ReasoningPart,
+  TextPart,
+  ToolResultPart2,
+} from '../core/message';
+
+function formatToolResultContent(llmContent: unknown): string {
+  if (typeof llmContent === 'string') {
+    const truncatedText =
+      llmContent.length > 200
+        ? `${llmContent.substring(0, 200)}...`
+        : llmContent;
+    return `: ${truncatedText}`;
+  }
+  if (Array.isArray(llmContent)) {
+    const textParts = llmContent
+      .filter((part): part is TextPart => part.type === 'text')
+      .map((part) => part.text)
+      .join(' ');
+    const truncatedText =
+      textParts.length > 200 ? `${textParts.substring(0, 200)}...` : textParts;
+    if (truncatedText) {
+      return `: ${truncatedText}`;
+    }
+  }
+  return '';
+}
+
+/**
+ * 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 function normalizeMessagesForCompact(
+  messages: NormalizedMessage[],
+): NormalizedMessage[] {
+  return messages
+    .map((message) => {
+      if (message.role === 'assistant') {
+        if (Array.isArray(message.content)) {
+          const filteredContent = message.content.filter(
+            (part): part is TextPart | ReasoningPart =>
+              part.type === 'text' || part.type === 'reasoning',
+          );
+
+          if (filteredContent.length === 0) {
+            return {
+              ...message,
+              content: [
+                {
+                  type: 'text' as const,
+                  text: '[Assistant performed tool operations]',
+                },
+              ],
+            };
+          }
+
+          // If there's no text content, convert reasoning to text for readability
+          const hasTextPart = filteredContent.some(
+            (part) => part.type === 'text',
+          );
+          if (!hasTextPart) {
+            const reasoningTexts = filteredContent
+              .filter(
+                (part): part is ReasoningPart => part.type === 'reasoning',
+              )
+              .map((part) => part.text)
+              .filter((text) => text.trim().length > 0);
+
+            if (reasoningTexts.length > 0) {
+              return {
+                ...message,
+                content: [
+                  {
+                    type: 'text' as const,
+                    text: reasoningTexts.join('\n'),
+                  },
+                ],
+              };
+            }
+
+            // If even reasoning is empty, use default text
+            return {
+              ...message,
+              content: [
+                {
+                  type: 'text' as const,
+                  text: '[Assistant performed tool operations]',
+                },
+              ],
+            };
+          }
+
+          return {
+            ...message,
+            content: filteredContent,
+          };
+        }
+        return message;
+      }
+
+      if (message.role === 'tool') {
+        if (Array.isArray(message.content)) {
+          const toolSummaries = message.content.map((part: ToolResultPart2) => {
+            if (part.type === 'tool-result') {
+              const result = part.result;
+              let summary = `Tool ${part.toolName} executed`;
+
+              if (
+                result &&
+                typeof result === 'object' &&
+                'llmContent' in result
+              ) {
+                const contentSuffix = formatToolResultContent(
+                  result.llmContent,
+                );
+                summary += contentSuffix || ' successfully';
+              } else {
+                summary += ' successfully';
+              }
+
+              return summary;
+            }
+            return 'Tool operation completed';
+          });
+
+          return {
+            ...message,
+            role: 'user' as const,
+            content: `[Tool Results Summary: ${toolSummaries.join('; ')}]`,
+          };
+        }
+
+        return {
+          ...message,
+          role: 'user' as const,
+          content: '[Tool operations completed]',
+        };
+      }
+
+      return message;
+    })
+    .filter((message) => {
+      if (typeof message.content === 'string') {
+        return message.content.trim().length > 0;
+      }
+      if (Array.isArray(message.content)) {
+        return message.content.length > 0;
+      }
+      return true;
+    });
+}

package/src/utils/path.ts

@@ -0,0 +1,98 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'pathe';
+
+export function relativeToHome(p: string) {
+  return p.replace(os.homedir(), '~');
+}
+
+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 function isPathWithin(childPath: string, parentPath: string): boolean {
+  const relative = path.relative(parentPath, childPath);
+  // If relative path starts with .., childPath is not within parentPath
+  return !relative.startsWith('..') && !path.isAbsolute(relative);
+}
+
+/**
+ * Validate directory path
+ * @param inputPath Path input by user
+ * @param existingDirectories List of existing working directories (including cwd)
+ * @returns Validation result
+ */
+export function validateDirectoryPath(
+  inputPath: string,
+  existingDirectories: string[],
+): PathValidationResult {
+  // Check for empty path
+  if (!inputPath || inputPath.trim() === '') {
+    return { resultType: 'emptyPath' };
+  }
+
+  // Resolve to absolute path
+  const absolutePath = path.resolve(inputPath.trim());
+
+  // Check if path exists
+  if (!fs.existsSync(absolutePath)) {
+    return {
+      resultType: 'pathNotFound',
+      directoryPath: inputPath,
+      absolutePath,
+    };
+  }
+
+  // Check if it's a directory
+  const stats = fs.statSync(absolutePath);
+  if (!stats.isDirectory()) {
+    return {
+      resultType: 'notADirectory',
+      directoryPath: inputPath,
+      absolutePath,
+    };
+  }
+
+  // Check if already in existing working directories
+  for (const existingDir of existingDirectories) {
+    if (isPathWithin(absolutePath, existingDir)) {
+      return {
+        resultType: 'alreadyInWorkingDirectory',
+        directoryPath: inputPath,
+        workingDir: existingDir,
+      };
+    }
+  }
+
+  return { resultType: 'success', absolutePath };
+}
+
+/**
+ * Format validation result into user-friendly message
+ */
+export function formatValidationMessage(result: PathValidationResult): string {
+  switch (result.resultType) {
+    case 'emptyPath':
+      return 'Please provide a directory path.';
+    case 'pathNotFound':
+      return `Path ${result.directoryPath} does not exist.`;
+    case 'notADirectory': {
+      const parentDir = path.dirname(result.absolutePath);
+      return `${result.directoryPath} is not a directory. Would you like to add parent directory ${parentDir}?`;
+    }
+    case 'alreadyInWorkingDirectory':
+      return `${result.directoryPath} is already within existing working directory ${result.workingDir}.`;
+    case 'success':
+      return `Successfully added ${result.absolutePath} as working directory.`;
+  }
+}

package/src/utils/prependSystemMessageMiddleware.ts

@@ -0,0 +1,16 @@
+import type { LanguageModelMiddleware } from 'ai';
+
+export const prependSystemMessageMiddleware: LanguageModelMiddleware = {
+  transformParams: async ({ params }) => {
+    return {
+      ...params,
+      prompt: [
+        {
+          role: 'system' as const,
+          content: "You are Claude Code, Anthropic's official CLI for Claude.",
+        },
+        ...params.prompt,
+      ],
+    };
+  },
+};

package/src/utils/project.ts

@@ -0,0 +1,32 @@
+import fs from 'fs';
+import { homedir } from 'os';
+import path from 'pathe';
+
+const PROJECT_MARKERS = [
+  'package.json',
+  'Cargo.toml',
+  'pyproject.toml',
+  'go.mod',
+  'composer.json',
+  'pom.xml',
+  'build.gradle',
+  'requirements.txt',
+  'Gemfile',
+  'mix.exs',
+  'deno.json',
+  'deno.jsonc',
+];
+
+export function isProjectDirectory(cwd: string): boolean {
+  const normalizedCwd = path.resolve(cwd);
+  const homeDir = path.resolve(homedir());
+
+  if (normalizedCwd === homeDir) {
+    return false;
+  }
+
+  return PROJECT_MARKERS.some((marker) => {
+    const markerPath = path.join(normalizedCwd, marker);
+    return fs.existsSync(markerPath);
+  });
+}

package/src/utils/proxy.ts

@@ -0,0 +1,102 @@
+/**
+ * HTTP Proxy utilities for AI model providers
+ * Handles proxy configuration and custom fetch implementation
+ */
+
+import type { Dispatcher, RequestInit as UndiciRequestInit } from 'undici';
+import { ProxyAgent } from 'undici';
+
+// Module-level cache for ProxyAgent instances (one per unique proxy URL)
+const proxyAgents = new Map<string, ProxyAgent>();
+
+// Module-level cache for undici fetch
+let undiciFetch: typeof import('undici').fetch | null = null;
+
+/**
+ * Validate proxy URL format
+ * @param proxyUrl - Proxy URL to validate
+ * @returns true if valid, false otherwise
+ */
+function isValidProxyUrl(proxyUrl: string): boolean {
+  try {
+    const url = new URL(proxyUrl);
+    // Support http, https, socks5, socks4 protocols
+    return ['http:', 'https:', 'socks5:', 'socks4:'].includes(url.protocol);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 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 function createProxyFetch(proxyUrl: string) {
+  // Validate proxy URL format
+  if (!isValidProxyUrl(proxyUrl)) {
+    console.warn(
+      `[Proxy] Invalid proxy URL format: ${proxyUrl}. Expected format: http://host:port, https://host:port, or socks5://host:port`,
+    );
+    return fetch;
+  }
+
+  // Get or create ProxyAgent for this URL
+  let proxyAgent = proxyAgents.get(proxyUrl);
+
+  if (!proxyAgent) {
+    try {
+      proxyAgent = new ProxyAgent(proxyUrl);
+      proxyAgents.set(proxyUrl, proxyAgent);
+    } catch (error) {
+      console.error(
+        `[Proxy] Failed to create ProxyAgent for ${proxyUrl}:`,
+        error,
+      );
+      // Return native fetch as fallback
+      return fetch;
+    }
+  }
+
+  // Return a fetch-compatible function
+  return async (input: string | URL | Request, init?: RequestInit) => {
+    // Lazy load undici fetch (cached at module level)
+    if (!undiciFetch) {
+      undiciFetch = (await import('undici')).fetch;
+    }
+
+    // Handle different input types properly
+    let url: string;
+    let requestInit: RequestInit | undefined = init;
+
+    if (input instanceof Request) {
+      // Extract all request properties, not just URL
+      url = input.url;
+      requestInit = {
+        method: input.method,
+        headers: input.headers,
+        body: input.body,
+        ...init, // Allow overrides
+      };
+    } else if (input instanceof URL) {
+      url = input.toString();
+    } else {
+      url = String(input);
+    }
+
+    // undici fetch with ProxyAgent dispatcher
+    // Use undici's RequestInit type to avoid compatibility issues
+    return undiciFetch(url, {
+      ...requestInit,
+      dispatcher: proxyAgent,
+    } as UndiciRequestInit);
+  };
+}

package/src/utils/randomUUID.ts

@@ -0,0 +1,11 @@
+/**
+ * Generate a random UUID v4 compatible string
+ * Compatible with Node.js 18+ without using crypto module
+ */
+export function randomUUID(): string {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}

package/src/utils/renderSessionMarkdown.ts

@@ -0,0 +1,175 @@
+import type {
+  AssistantContent,
+  NormalizedMessage,
+  TextPart,
+  ToolContent,
+  ToolResultPart2,
+  UserContent,
+} from '../core/message';
+
+export function renderSessionMarkdown(opts: {
+  sessionId: string;
+  title: string;
+  projectPath: string;
+  model: string | null;
+  messages: NormalizedMessage[];
+  createdAt: Date;
+  updatedAt: Date;
+}): string {
+  const lines: string[] = [];
+
+  const title = normalizeTitle(opts.title) || `Session ${opts.sessionId}`;
+
+  lines.push(`# ${title}`);
+  lines.push('');
+  lines.push(`**Session ID:** ${opts.sessionId}`);
+  lines.push(`**Project:** ${opts.projectPath}`);
+  lines.push(`**Model:** ${opts.model ?? ''}`);
+  lines.push(`**Created:** ${formatDate(opts.createdAt)}`);
+  lines.push(`**Updated:** ${formatDate(opts.updatedAt)}`);
+  lines.push('');
+  lines.push('---');
+  lines.push('');
+
+  opts.messages.forEach((m) => {
+    if (m.role === 'system') return;
+
+    const header = (() => {
+      if (m.role === 'user') return '## User';
+      if (m.role === 'tool') return '## Tool';
+      if (m.role === 'assistant') {
+        return '## Assistant';
+      }
+      return '## Message';
+    })();
+
+    if (header) {
+      lines.push(header);
+      lines.push('');
+    }
+
+    if (m.role === 'tool') {
+      const toolContent = m.content as ToolResultPart2[];
+      for (const part of toolContent) {
+        lines.push(`Tool: ${part.toolName}`);
+        const toolModel = getModelFromToolResultPart(part);
+        if (toolModel && shouldShowModel(toolModel, opts.model)) {
+          lines.push('');
+          lines.push(`**Model:** ${toolModel}`);
+        }
+        lines.push('');
+        lines.push('**Input:**');
+        lines.push('```json');
+        lines.push(JSON.stringify(part.input ?? {}, null, 2));
+        lines.push('```');
+        lines.push('');
+        lines.push('**Output:**');
+        lines.push('```');
+        lines.push(renderToolResultOutput(part.result.llmContent));
+        lines.push('```');
+        lines.push('');
+      }
+      return;
+    }
+
+    const content = renderMessageContent(m.content);
+    if (content) lines.push(content);
+    lines.push('');
+  });
+
+  return lines.join('\n');
+}
+
+function renderMessageContent(
+  content: UserContent | AssistantContent | ToolContent | ToolResultPart2[],
+): string {
+  if (typeof content === 'string') return content;
+
+  return content
+    .map((part) => {
+      if (!('type' in part)) return String(part);
+
+      if (part.type === 'text') return (part as TextPart).text;
+
+      if (part.type === 'reasoning') {
+        return `_Thinking:_\n\n${part.text}\n`;
+      }
+
+      if (part.type === 'tool_use') {
+        return `Tool: ${part.name}
+
+**Input:**
+
+\`\`\`json
+${JSON.stringify(part.input ?? {}, null, 2)}
+\`\`\`
+
+**Output:**`;
+      }
+
+      if (part.type === 'tool_result') {
+        const result = part.result;
+        return `
+
+\`\`\`
+${renderToolResultOutput(result.llmContent)}
+\`\`\`
+`;
+      }
+
+      return `\n\`\`\`\n[${part.type}]\n\`\`\`\n`;
+    })
+    .join('\n');
+}
+
+function renderToolResultOutput(
+  output: TextPart['text'] | Array<TextPart | { type: 'image' }>,
+): string {
+  if (typeof output === 'string') return output;
+  return output
+    .filter((p): p is TextPart => p.type === 'text')
+    .map((p) => p.text)
+    .join('');
+}
+
+function normalizeTitle(text: string): string {
+  const trimmed = text.trim();
+  if (!trimmed) return '';
+  return trimmed
+    .split(/\r\n|\r|\n/)[0]
+    .slice(0, 80)
+    .trim();
+}
+
+function formatDate(date: Date): string {
+  return date.toLocaleString();
+}
+
+function getModelFromToolResultPart(part: ToolResultPart2): string | null {
+  if (part.toolName !== 'task') return null;
+
+  const returnDisplay = part.result.returnDisplay;
+  if (!returnDisplay) return null;
+  if (typeof returnDisplay !== 'object') return null;
+  if (!('type' in returnDisplay)) return null;
+  if (returnDisplay.type !== 'agent_result') return null;
+  if (!('model' in returnDisplay)) return null;
+
+  const model = returnDisplay.model;
+  return typeof model === 'string' ? model : null;
+}
+
+function shouldShowModel(model: string, mainModel: string | null): boolean {
+  if (!model) return false;
+  if (!mainModel) return true;
+
+  if (mainModel === model) return false;
+
+  const parts = mainModel.split('/');
+  if (parts.length >= 2) {
+    const id = parts.slice(1).join('/');
+    if (id === model) return false;
+  }
+
+  return true;
+}