oricore 1.0.0

package/src/utils/env.ts

@@ -0,0 +1,90 @@
+function getTerminal() {
+  if (process.env.CURSOR_TRACE_ID) return 'cursor';
+  if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes('/.cursor-server/bin/'))
+    return 'cursor';
+  if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes('/.windsurf-server/bin/'))
+    return 'windsurf';
+  const A = process.env.__CFBundleIdentifier?.toLowerCase();
+  if (A?.includes('vscodium')) return 'codium';
+  if (A?.includes('windsurf')) return 'windsurf';
+  if (A?.includes('pycharm')) return 'pycharm';
+  if (A?.includes('intellij')) return 'intellij';
+  if (A?.includes('webstorm')) return 'webstorm';
+  if (A?.includes('phpstorm')) return 'phpstorm';
+  if (A?.includes('rubymine')) return 'rubymine';
+  if (A?.includes('clion')) return 'clion';
+  if (A?.includes('goland')) return 'goland';
+  if (A?.includes('rider')) return 'rider';
+  if (A?.includes('datagrip')) return 'datagrip';
+  if (A?.includes('appcode')) return 'appcode';
+  if (A?.includes('dataspell')) return 'dataspell';
+  if (A?.includes('aqua')) return 'aqua';
+  if (A?.includes('gateway')) return 'gateway';
+  if (A?.includes('fleet')) return 'fleet';
+  if (A?.includes('com.google.android.studio')) return 'androidstudio';
+  if (process.env.TERMINAL_EMULATOR === 'JetBrains-JediTerm') return 'pycharm';
+  if (process.env.TERM === 'xterm-ghostty') return 'ghostty';
+  if (process.env.TERM?.includes('kitty')) return 'kitty';
+  if (process.env.TERM_PROGRAM) return process.env.TERM_PROGRAM;
+  if (process.env.TMUX) return 'tmux';
+  if (process.env.STY) return 'screen';
+  if (process.env.KONSOLE_VERSION) return 'konsole';
+  if (process.env.GNOME_TERMINAL_SERVICE) return 'gnome-terminal';
+  if (process.env.XTERM_VERSION) return 'xterm';
+  if (process.env.VTE_VERSION) return 'vte-based';
+  if (process.env.TERMINATOR_UUID) return 'terminator';
+  if (process.env.KITTY_WINDOW_ID) return 'kitty';
+  if (process.env.ALACRITTY_LOG) return 'alacritty';
+  if (process.env.TILIX_ID) return 'tilix';
+  if (process.env.WT_SESSION) return 'windows-terminal';
+  if (process.env.SESSIONNAME && process.env.TERM === 'cygwin') return 'cygwin';
+  if (process.env.MSYSTEM) return process.env.MSYSTEM.toLowerCase();
+  if (process.env.ConEmuTask) return 'conemu';
+  if (process.env.WSL_DISTRO_NAME) return `wsl-${process.env.WSL_DISTRO_NAME}`;
+  if (
+    process.env.SSH_CONNECTION ||
+    process.env.SSH_CLIENT ||
+    process.env.SSH_TTY
+  )
+    return 'ssh-session';
+  if (process.env.TERM) {
+    const B = process.env.TERM;
+    if (B.includes('alacritty')) return 'alacritty';
+    if (B.includes('rxvt')) return 'rxvt';
+    if (B.includes('termite')) return 'termite';
+    return process.env.TERM;
+  }
+  if (!process.stdout.isTTY) return 'non-interactive';
+  return null;
+}
+
+async function getHasInternetAccess() {
+  try {
+    const abort = new AbortController(),
+      timer = setTimeout(() => abort.abort(), 1000);
+    return (
+      await fetch('http://1.1.1.1', {
+        method: 'HEAD',
+        signal: abort.signal,
+      }),
+      clearTimeout(timer),
+      true
+    );
+  } catch {
+    return false;
+  }
+}
+
+export async function getEnv() {
+  return {
+    hasInternetAccess: await getHasInternetAccess(),
+    platform:
+      process.platform === 'win32'
+        ? 'windows'
+        : process.platform === 'darwin'
+          ? 'macos'
+          : 'linux',
+    nodeVersion: process.version,
+    terminal: getTerminal(),
+  };
+}

package/src/utils/error.ts

@@ -0,0 +1,38 @@
+import { TOOL_NAMES } from '../core/constants';
+
+export function getErrorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  try {
+    return String(error);
+  } catch {
+    return 'Failed to get error details';
+  }
+}
+
+export class MaxFileReadLengthExceededError extends Error {
+  public readonly maxFileLength: number;
+  public readonly fileLength: number;
+  constructor(fileLength: number, maxFileLength: number) {
+    super(
+      `File content (${fileLength} characters) exceeds maximum allowed length (${maxFileLength} characters). Please use offset and limit parameters to read specific portions of the file, or use the ${TOOL_NAMES.GREP} tool to search for specific content.`,
+    );
+    this.name = 'MaxFileReadLengthExceededError';
+    this.maxFileLength = maxFileLength;
+    this.fileLength = fileLength;
+  }
+}
+
+export class MaxFileReadTokenExceededError extends Error {
+  public readonly maxTokens: number;
+  public readonly tokenCount: number;
+  constructor(tokenCount: number, maxTokens: number) {
+    super(
+      `File content (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}). Please use offset and limit parameters to read specific portions of the file, or use the ${TOOL_NAMES.GREP} tool to search for specific content.`,
+    );
+    this.name = 'MaxFileReadTokenExceededError';
+    this.maxTokens = maxTokens;
+    this.tokenCount = tokenCount;
+  }
+}

package/src/utils/execFileNoThrow.ts

@@ -0,0 +1,49 @@
+import { execFile } from 'child_process';
+
+const MS_IN_SECOND = 1000;
+const SECONDS_IN_MINUTE = 60;
+
+/**
+ * execFile, but always resolves (never throws)
+ */
+export function execFileNoThrow(
+  cwd: string,
+  file: string,
+  args: string[],
+  abortSignal?: AbortSignal,
+  timeout = 10 * SECONDS_IN_MINUTE * MS_IN_SECOND,
+  preserveOutputOnError = true,
+): Promise<{ stdout: string; stderr: string; code: number }> {
+  return new Promise((resolve) => {
+    try {
+      execFile(
+        file,
+        args,
+        {
+          maxBuffer: 1_000_000,
+          signal: abortSignal,
+          timeout,
+          cwd,
+        },
+        (error, stdout, stderr) => {
+          if (error) {
+            if (preserveOutputOnError) {
+              const errorCode = typeof error.code === 'number' ? error.code : 1;
+              resolve({
+                stdout: stdout || '',
+                stderr: stderr || '',
+                code: errorCode,
+              });
+            } else {
+              resolve({ stdout: '', stderr: '', code: 1 });
+            }
+          } else {
+            resolve({ stdout, stderr, code: 0 });
+          }
+        },
+      );
+    } catch (error) {
+      resolve({ stdout: '', stderr: '', code: 1 });
+    }
+  });
+}

package/src/utils/files.ts

@@ -0,0 +1,93 @@
+import path from 'pathe';
+import { execFileNoThrow } from './execFileNoThrow';
+import { listDirectory } from './list';
+
+export interface FileItem {
+  path: string;
+  type: 'file' | 'directory';
+  name: string;
+}
+
+async function getGitStatusItems(cwd: string, query?: string) {
+  const gitStatus = await (async () => {
+    // won't throw error
+    const { stdout } = await execFileNoThrow(
+      cwd,
+      'git',
+      ['status', '--short'],
+      undefined,
+      undefined,
+      false,
+    );
+    // DO NOT USE TRIM HERE, it will make the result inconsistent
+    return stdout;
+  })();
+
+  const files = gitStatus
+    .split('\n')
+    .filter((line) => line.trim().length > 0)
+    .filter(
+      (line) =>
+        !line.startsWith('D') &&
+        !line.startsWith('??') &&
+        !line.startsWith('R'),
+    )
+    .map((line) => line.slice(3))
+    .filter(
+      (path) => !query || path.toLowerCase().includes(query.toLowerCase()),
+    );
+
+  return Promise.all(
+    files.map(async (file) => {
+      const relativePath = path.join(cwd, file);
+      const name = path.basename(file);
+      const item = await createFileItem(relativePath, name, 'file');
+      return item;
+    }),
+  );
+}
+
+export async function getFiles(opts: {
+  cwd: string;
+  maxSize: number;
+  query: string;
+}) {
+  const { cwd, query, maxSize } = opts;
+  let items = await getGitStatusItems(cwd, query);
+  if (items.length < maxSize) {
+    const remainingSize = maxSize - items.length;
+    const result = listDirectory(cwd, cwd, 6000).filter(
+      (item) => !query || item.toLowerCase().includes(query.toLowerCase()),
+    );
+    const remainingItems = result
+      .slice(0, remainingSize)
+      .map((item) => {
+        const isDir = item.endsWith(path.sep);
+        const name = path.basename(item) + (isDir ? path.sep : '');
+        const type: 'file' | 'directory' = isDir ? 'directory' : 'file';
+        return createFileItem(item, name, type);
+      })
+      .sort((a, b) => {
+        if (a.type !== b.type) {
+          return a.type === 'directory' ? -1 : 1;
+        }
+
+        return a.path.localeCompare(b.path);
+      });
+    items = [...items, ...remainingItems];
+  }
+  return items;
+}
+
+function createFileItem(
+  relativePath: string,
+  name: string,
+  type: 'file' | 'directory',
+): FileItem {
+  const fileItem: FileItem = {
+    path: relativePath,
+    type,
+    name,
+  };
+  return fileItem;
+}