oricore 1.0.0

package/src/utils/list.ts

@@ -0,0 +1,200 @@
+import createDebug from 'debug';
+import fs from 'fs';
+import { basename, join, relative, sep } from 'pathe';
+import { isIgnored } from './ignore';
+export const MAX_FILES = 1000;
+export const TRUNCATED_MESSAGE = `There are more than ${MAX_FILES} files in the repository. Use the LS tool (passing a specific path), Bash tool, and other tools to explore nested directories. The first ${MAX_FILES} files and directories are included below:\n\n`;
+
+const debug = createDebug('oricore:utils:list');
+
+// List of product names to check for ignore files
+const PRODUCT_NAMES = ['oricore', 'takumi', 'kwaipilot'];
+
+export function listDirectory(
+  initialPath: string,
+  cwd: string,
+  maxFiles: number = MAX_FILES,
+) {
+  const results: string[] = [];
+  const queue = [initialPath];
+  while (queue.length > 0) {
+    if (results.length > maxFiles) {
+      return results;
+    }
+    const path = queue.shift()!;
+    if (skip(path)) {
+      continue;
+    }
+    if (path !== initialPath) {
+      results.push(relative(cwd, path) + sep);
+    }
+    let children: fs.Dirent[];
+    try {
+      children = fs.readdirSync(path, { withFileTypes: true });
+    } catch (e) {
+      // eg. EPERM, EACCES, ENOENT, etc.
+      // Silently skip directories we don't have permission to read
+      debug(`[LsTool] Error listing directory: ${path}`, e);
+      continue;
+    }
+    for (const child of children) {
+      if (child.name === 'node_modules') {
+        continue;
+      }
+
+      const childPath = join(path, child.name);
+
+      // Skip if ignored by any of the product-specific ignore files
+      if (isIgnored(childPath, cwd, PRODUCT_NAMES)) {
+        continue;
+      }
+
+      if (child.isDirectory()) {
+        queue.push(childPath + sep);
+      } else {
+        if (skip(childPath)) {
+          continue;
+        }
+        results.push(relative(cwd, childPath));
+        if (results.length > maxFiles) {
+          return results;
+        }
+      }
+    }
+  }
+  return results;
+}
+
+const SKIP_DOT_FILES = new Set([
+  '.git',
+  '.env',
+  '.vscode',
+  '.idea',
+  '.bashrc',
+  '.bash_profile',
+  '.zshrc',
+  '.zprofile',
+  '.profile',
+  '.DS_Store',
+  '.localized',
+  'Thumbs.db',
+  'desktop.ini',
+]);
+
+function skip(path: string) {
+  const name = basename(path);
+  if (path !== '.' && SKIP_DOT_FILES.has(name)) {
+    return true;
+  }
+  return false;
+}
+
+export function listRootDirectory(rootPath: string): string[] {
+  const results: string[] = [];
+  try {
+    const children = fs.readdirSync(rootPath, { withFileTypes: true });
+    for (const child of children) {
+      if (child.name === 'node_modules' || child.name.startsWith('.')) {
+        continue;
+      }
+
+      const childPath = join(rootPath, child.name);
+
+      // Skip if ignored by any of the product-specific ignore files
+      if (isIgnored(childPath, rootPath, PRODUCT_NAMES)) {
+        continue;
+      }
+
+      if (child.isDirectory()) {
+        results.push(child.name + sep);
+      } else {
+        results.push(child.name);
+      }
+    }
+  } catch (e) {
+    // Silently skip root directories we don't have permission to read
+  }
+  return results;
+}
+
+type TreeNode = {
+  name: string;
+  path: string;
+  type: 'file' | 'directory';
+  children?: TreeNode[];
+};
+
+export function createFileTree(sortedPaths: string[]): TreeNode[] {
+  const root: TreeNode[] = [];
+
+  for (const path of sortedPaths) {
+    const parts = path.split(sep);
+    let currentLevel = root;
+    let currentPath = '';
+
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i]!;
+      if (!part) {
+        // directories have trailing slashes
+        continue;
+      }
+      currentPath = currentPath ? `${currentPath}${sep}${part}` : part;
+      const isLastPart = i === parts.length - 1;
+
+      const existingNode = currentLevel.find((node) => node.name === part);
+
+      if (existingNode) {
+        currentLevel = existingNode.children || [];
+      } else {
+        const newNode: TreeNode = {
+          name: part,
+          path: currentPath,
+          type: isLastPart ? 'file' : 'directory',
+        };
+
+        if (!isLastPart) {
+          newNode.children = [];
+        }
+
+        currentLevel.push(newNode);
+        currentLevel = newNode.children || [];
+      }
+    }
+  }
+
+  return root;
+}
+
+/**
+ * eg.
+ * - src/
+ *   - index.ts
+ *   - utils/
+ *     - file.ts
+ */
+export function printTree(
+  cwd: string,
+  tree: TreeNode[],
+  level = 0,
+  prefix = '',
+): string {
+  let result = '';
+
+  // Add absolute path at root level
+  if (level === 0) {
+    result += `- ${cwd}${sep}\n`;
+    prefix = '  ';
+  }
+
+  for (const node of tree) {
+    // Add the current node to the result
+    result += `${prefix}${'-'} ${node.name}${node.type === 'directory' ? sep : ''}\n`;
+
+    // Recursively print children if they exist
+    if (node.children && node.children.length > 0) {
+      result += printTree(cwd, node.children, level + 1, `${prefix}  `);
+    }
+  }
+
+  return result;
+}

package/src/utils/mergeSystemMessagesMiddleware.ts

@@ -0,0 +1,32 @@
+import type { LanguageModelMiddleware } from 'ai';
+
+export const mergeSystemMessagesMiddleware: LanguageModelMiddleware = {
+  transformParams: async ({ params }) => {
+    const mergedPrompt: typeof params.prompt = [];
+    let pendingSystemContent: string[] = [];
+
+    for (const msg of params.prompt) {
+      if (msg.role === 'system') {
+        pendingSystemContent.push(msg.content);
+      } else {
+        if (pendingSystemContent.length > 0) {
+          mergedPrompt.push({
+            role: 'system' as const,
+            content: pendingSystemContent.join('\n\n'),
+          });
+          pendingSystemContent = [];
+        }
+        mergedPrompt.push(msg);
+      }
+    }
+
+    if (pendingSystemContent.length > 0) {
+      mergedPrompt.push({
+        role: 'system' as const,
+        content: pendingSystemContent.join('\n\n'),
+      });
+    }
+
+    return { ...params, prompt: mergedPrompt };
+  },
+};

package/src/utils/messageNormalization.test.ts

@@ -0,0 +1,401 @@
+import { describe, expect, test } from 'vitest';
+import type { NormalizedMessage } from '../core/message';
+import { normalizeMessagesForCompact } from './messageNormalization';
+
+describe('normalizeMessagesForCompact', () => {
+  test('should keep text and reasoning content in assistant messages', () => {
+    const messages: NormalizedMessage[] = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'text', text: 'I will help you' },
+          { type: 'reasoning', text: 'Need to check the file first' },
+          {
+            type: 'tool_use',
+            id: '1',
+            name: 'read',
+            input: { file_path: 'test.ts' },
+          },
+        ],
+        text: 'I will help you',
+        model: 'gpt-4',
+        usage: {
+          input_tokens: 100,
+          output_tokens: 50,
+        },
+        type: 'message',
+        timestamp: '2024-01-01',
+        uuid: 'uuid-1',
+        parentUuid: null,
+      },
+    ];
+
+    const result = normalizeMessagesForCompact(messages);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].role).toBe('assistant');
+    expect(result[0].content).toEqual([
+      { type: 'text', text: 'I will help you' },
+      { type: 'reasoning', text: 'Need to check the file first' },
+    ]);
+  });
+
+  test('should create placeholder text when assistant has only tool_use', () => {
+    const messages: NormalizedMessage[] = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: 'tool_use',
+            id: '1',
+            name: 'read',
+            input: { file_path: 'test.ts' },
+          },
+        ],
+        text: '',
+        model: 'gpt-4',
+        usage: {
+          input_tokens: 100,
+          output_tokens: 50,
+        },
+        type: 'message',
+        timestamp: '2024-01-01',
+        uuid: 'uuid-1',
+        parentUuid: null,
+      },
+    ];
+
+    const result = normalizeMessagesForCompact(messages);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].content).toEqual([
+      { type: 'text', text: '[Assistant performed tool operations]' },
+    ]);
+  });
+
+  test('should convert reasoning-only assistant content to readable text', () => {
+    const messages: NormalizedMessage[] = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: 'reasoning',
+            text: 'The user asked me to revert recent changes to manifest.json.',
+          },
+          {
+            type: 'tool_use',
+            id: 'toolu_vrtx_011pD7AhictqR2PsxdL3vE9L',
+            name: 'write',
+            input: {
+              content: '{ "name": "Node Link Handling Plugin" }',
+              file_path: '/tmp/manifest.json',
+            },
+            description: 'packages/figma-link-plugin/manifest.json',
+          },
+        ],
+        text: '',
+        model: 'claude-4.5-sonnet',
+        usage: {
+          input_tokens: 139630,
+          output_tokens: 308,
+        },
+        type: 'message',
+        timestamp: '2025-11-27T09:42:48.764Z',
+        uuid: '1f050587-ecb1-41f7-97f3-b2d5acb6cb08',
+        parentUuid: '19c7f79b-71fe-4d77-bf3d-fcc6080be42f',
+      },
+    ];
+
+    const result = normalizeMessagesForCompact(messages);
+
+    expect(result).toHaveLength(1);
+    const content = result[0].content;
+    expect(Array.isArray(content)).toBe(true);
+    expect(content).toEqual([
+      {
+        type: 'text',
+        text: 'The user asked me to revert recent changes to manifest.json.',
+      },
+    ]);
+  });
+
+  test('should handle multiple reasoning parts by joining them', () => {
+    const messages: NormalizedMessage[] = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: 'reasoning',
+            text: 'First, I need to analyze the request.',
+          },
+          {
+            type: 'reasoning',
+            text: 'Then, I will execute the appropriate tool.',
+          },
+          {
+            type: 'tool_use',
+            id: 'tool-1',
+            name: 'bash',
+            input: { command: 'ls' },
+          },
+        ],
+        text: '',
+        model: 'test-model',
+        usage: { input_tokens: 100, output_tokens: 50 },
+        type: 'message',
+        timestamp: '2025-11-27T10:00:00.000Z',
+        uuid: 'test-uuid',
+        parentUuid: null,
+      },
+    ];
+
+    const result = normalizeMessagesForCompact(messages);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].content).toEqual([
+      {
+        type: 'text',
+        text: 'First, I need to analyze the request.\nThen, I will execute the appropriate tool.',
+      },
+    ]);
+  });
+
+  test('should use default text when reasoning contains only whitespace', () => {
+    const messages: NormalizedMessage[] = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: 'reasoning',
+            text: '   \n  \t  ',
+          },
+          {
+            type: 'tool_use',
+            id: 'tool-1',
+            name: 'read',
+            input: { file_path: 'test.ts' },
+          },
+        ],
+        text: '',
+        model: 'test-model',
+        usage: { input_tokens: 100, output_tokens: 50 },
+        type: 'message',
+        timestamp: '2025-11-27T10:00:00.000Z',
+        uuid: 'test-uuid',
+        parentUuid: null,
+      },
+    ];
+
+    const result = normalizeMessagesForCompact(messages);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].content).toEqual([
+      {
+        type: 'text',
+        text: '[Assistant performed tool operations]',
+      },
+    ]);
+  });
+
+  test('should preserve text content when both text and reasoning exist', () => {
+    const messages: NormalizedMessage[] = [
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: 'text',
+            text: 'Let me help you with that.',
+          },
+          {
+            type: 'reasoning',
+            text: 'Internal thought process...',
+          },
+          {
+            type: 'tool_use',
+            id: 'tool-1',
+            name: 'write',
+            input: { file_path: 'test.ts', content: 'code' },
+          },
+        ],
+        text: 'Let me help you with that.',
+        model: 'test-model',
+        usage: { input_tokens: 100, output_tokens: 50 },
+        type: 'message',
+        timestamp: '2025-11-27T10:00:00.000Z',
+        uuid: 'test-uuid',
+        parentUuid: null,
+      },
+    ];
+
+    const result = normalizeMessagesForCompact(messages);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].content).toEqual([
+      {
+        type: 'text',
+        text: 'Let me help you with that.',
+      },
+      {
+        type: 'reasoning',
+        text: 'Internal thought process...',
+      },
+    ]);
+  });
+
+  test('should convert tool messages to user messages with summary', () => {
+    const messages: NormalizedMessage[] = [
+      {
+        role: 'tool',
+        content: [
+          {
+            type: 'tool-result',
+            toolCallId: '1',
+            toolName: 'read',
+            input: { file_path: 'test.ts' },
+            result: {
+              llmContent: 'const x = 1;',
+              isError: false,
+            },
+          },
+        ],
+        type: 'message',
+        timestamp: '2024-01-01',
+        uuid: 'uuid-2',
+        parentUuid: 'uuid-1',
+      },
+    ];
+
+    const result = normalizeMessagesForCompact(messages);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].role).toBe('user');
+    expect(result[0].content).toContain('Tool read executed');
+    expect(result[0].content).toContain('const x = 1;');
+  });
+
+  test('should keep regular user and system messages unchanged', () => {
+    const messages: NormalizedMessage[] = [
+      {
+        role: 'system',
+        content: 'You are a helpful assistant',
+        type: 'message',
+        timestamp: '2024-01-01',
+        uuid: 'uuid-0',
+        parentUuid: null,
+      },
+      {
+        role: 'user',
+        content: 'Help me with this task',
+        type: 'message',
+        timestamp: '2024-01-01',
+        uuid: 'uuid-1',
+        parentUuid: 'uuid-0',
+      },
+    ];
+
+    const result = normalizeMessagesForCompact(messages);
+
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual(messages[0]);
+    expect(result[1]).toEqual(messages[1]);
+  });
+
+  test('should truncate long tool results', () => {
+    const longText = 'a'.repeat(300);
+    const messages: NormalizedMessage[] = [
+      {
+        role: 'tool',
+        content: [
+          {
+            type: 'tool-result',
+            toolCallId: '1',
+            toolName: 'read',
+            input: { file_path: 'test.ts' },
+            result: {
+              llmContent: longText,
+              isError: false,
+            },
+          },
+        ],
+        type: 'message',
+        timestamp: '2024-01-01',
+        uuid: 'uuid-2',
+        parentUuid: 'uuid-1',
+      },
+    ];
+
+    const result = normalizeMessagesForCompact(messages);
+
+    expect(result).toHaveLength(1);
+    const content = result[0].content as string;
+    expect(content).toContain('...');
+    expect(content.length).toBeLessThan(longText.length + 100);
+  });
+
+  test('should filter out empty messages', () => {
+    const messages: NormalizedMessage[] = [
+      {
+        role: 'user',
+        content: 'Valid message',
+        type: 'message',
+        timestamp: '2024-01-01',
+        uuid: 'uuid-1',
+        parentUuid: null,
+      },
+      {
+        role: 'user',
+        content: '',
+        type: 'message',
+        timestamp: '2024-01-01',
+        uuid: 'uuid-2',
+        parentUuid: 'uuid-1',
+      },
+      {
+        role: 'user',
+        content: '   ',
+        type: 'message',
+        timestamp: '2024-01-01',
+        uuid: 'uuid-3',
+        parentUuid: 'uuid-2',
+      },
+    ];
+
+    const result = normalizeMessagesForCompact(messages);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].content).toBe('Valid message');
+  });
+
+  test('should handle tool results with array llmContent', () => {
+    const messages: NormalizedMessage[] = [
+      {
+        role: 'tool',
+        content: [
+          {
+            type: 'tool-result',
+            toolCallId: '1',
+            toolName: 'read',
+            input: { file_path: 'test.ts' },
+            result: {
+              llmContent: [
+                { type: 'text', text: 'First part' },
+                { type: 'text', text: 'Second part' },
+              ],
+              isError: false,
+            },
+          },
+        ],
+        type: 'message',
+        timestamp: '2024-01-01',
+        uuid: 'uuid-2',
+        parentUuid: 'uuid-1',
+      },
+    ];
+
+    const result = normalizeMessagesForCompact(messages);
+
+    expect(result).toHaveLength(1);
+    const content = result[0].content as string;
+    expect(content).toContain('First part Second part');
+  });
+});