@hasna/terminal 0.1.5 → 0.2.0

package/src/parsers/errors.ts

@@ -0,0 +1,107 @@
+// Parser for common error patterns
+
+import type { Parser, ErrorInfo } from "./base.js";
+
+const ERROR_PATTERNS: { type: string; pattern: RegExp; extract: (m: RegExpMatchArray, output: string) => ErrorInfo }[] = [
+  {
+    type: "port_in_use",
+    pattern: /EADDRINUSE.*?(?::(\d+))|port\s+(\d+)\s+(?:is\s+)?(?:already\s+)?in\s+use/i,
+    extract: (m) => ({
+      type: "port_in_use",
+      message: m[0],
+      suggestion: `Kill the process: lsof -i :${m[1] ?? m[2]} -t | xargs kill`,
+    }),
+  },
+  {
+    type: "file_not_found",
+    pattern: /ENOENT.*?'([^']+)'|No such file or directory:\s*(.+)/,
+    extract: (m) => ({
+      type: "file_not_found",
+      message: m[0],
+      file: m[1] ?? m[2]?.trim(),
+      suggestion: "Check the file path exists",
+    }),
+  },
+  {
+    type: "permission_denied",
+    pattern: /EACCES.*?'([^']+)'|Permission denied:\s*(.+)/,
+    extract: (m) => ({
+      type: "permission_denied",
+      message: m[0],
+      file: m[1] ?? m[2]?.trim(),
+      suggestion: "Check file permissions or run with sudo",
+    }),
+  },
+  {
+    type: "command_not_found",
+    pattern: /command not found:\s*(\S+)|(\S+):\s*not found/,
+    extract: (m) => ({
+      type: "command_not_found",
+      message: m[0],
+      suggestion: `Install ${m[1] ?? m[2]} or check your PATH`,
+    }),
+  },
+  {
+    type: "dependency_missing",
+    pattern: /Cannot find module\s+'([^']+)'|Module not found.*?'([^']+)'/,
+    extract: (m) => ({
+      type: "dependency_missing",
+      message: m[0],
+      suggestion: `Install: npm install ${m[1] ?? m[2]}`,
+    }),
+  },
+  {
+    type: "syntax_error",
+    pattern: /SyntaxError:\s*(.+)|error TS\d+:\s*(.+)/,
+    extract: (m, output) => {
+      const fileMatch = output.match(/(\S+\.\w+):(\d+)/);
+      return {
+        type: "syntax_error",
+        message: m[1] ?? m[2] ?? m[0],
+        file: fileMatch?.[1],
+        line: fileMatch ? parseInt(fileMatch[2]) : undefined,
+        suggestion: "Fix the syntax error in the referenced file",
+      };
+    },
+  },
+  {
+    type: "out_of_memory",
+    pattern: /ENOMEM|JavaScript heap out of memory|Killed/,
+    extract: (m) => ({
+      type: "out_of_memory",
+      message: m[0],
+      suggestion: "Increase memory: NODE_OPTIONS=--max-old-space-size=4096",
+    }),
+  },
+  {
+    type: "network_error",
+    pattern: /ECONNREFUSED|ENOTFOUND|ETIMEDOUT|fetch failed/,
+    extract: (m) => ({
+      type: "network_error",
+      message: m[0],
+      suggestion: "Check network connection and target URL/host",
+    }),
+  },
+];
+
+export const errorParser: Parser<ErrorInfo> = {
+  name: "error",
+
+  detect(_command: string, output: string): boolean {
+    return ERROR_PATTERNS.some(({ pattern }) => pattern.test(output));
+  },
+
+  parse(_command: string, output: string): ErrorInfo {
+    for (const { pattern, extract } of ERROR_PATTERNS) {
+      const match = output.match(pattern);
+      if (match) return extract(match, output);
+    }
+
+    // Generic error fallback
+    const errorLine = output.split("\n").find(l => /error/i.test(l));
+    return {
+      type: "unknown",
+      message: errorLine?.trim() ?? "Unknown error",
+    };
+  },
+};

package/src/parsers/files.ts

@@ -0,0 +1,91 @@
+// Parser for file listing output (ls -la, find, etc.)
+
+import type { Parser, FileEntry, SearchResult } from "./base.js";
+
+const NODE_MODULES_RE = /node_modules/;
+const DIST_RE = /\b(dist|build|\.next|__pycache__|coverage|\.git)\b/;
+const SOURCE_EXTS = /\.(ts|tsx|js|jsx|py|go|rs|java|rb|sh|c|cpp|h|css|scss|html|vue|svelte|md|json|yaml|yml|toml)$/;
+
+export const lsParser: Parser<FileEntry[]> = {
+  name: "ls",
+
+  detect(command: string, output: string): boolean {
+    return /^\s*(ls|ll|la)\b/.test(command) && output.includes(" ");
+  },
+
+  parse(_command: string, output: string): FileEntry[] {
+    const lines = output.split("\n").filter(l => l.trim());
+    const entries: FileEntry[] = [];
+
+    for (const line of lines) {
+      // ls -la format: drwxr-xr-x  5 user group 160 Mar 10 09:00 dirname
+      const match = line.match(/^([dlcbps-])([rwxsStT-]{9})\s+\d+\s+\S+\s+\S+\s+(\d+)\s+(\w+\s+\d+\s+[\d:]+)\s+(.+)$/);
+      if (match) {
+        const typeChar = match[1];
+        entries.push({
+          name: match[5],
+          type: typeChar === "d" ? "dir" : typeChar === "l" ? "symlink" : "file",
+          size: parseInt(match[3]),
+          modified: match[4],
+          permissions: match[1] + match[2],
+        });
+      } else if (line.trim() && !line.startsWith("total ")) {
+        // Simple ls output — just filenames
+        entries.push({ name: line.trim(), type: "file" });
+      }
+    }
+
+    return entries;
+  },
+};
+
+export const findParser: Parser<SearchResult> = {
+  name: "find",
+
+  detect(command: string, _output: string): boolean {
+    return /^\s*(find|fd)\b/.test(command);
+  },
+
+  parse(_command: string, output: string): SearchResult {
+    const lines = output.split("\n").filter(l => l.trim());
+    const source: FileEntry[] = [];
+    const other: FileEntry[] = [];
+    let nodeModulesCount = 0;
+    let distCount = 0;
+
+    for (const line of lines) {
+      const path = line.trim();
+      if (!path) continue;
+
+      if (NODE_MODULES_RE.test(path)) {
+        nodeModulesCount++;
+        continue;
+      }
+
+      if (DIST_RE.test(path)) {
+        distCount++;
+        continue;
+      }
+
+      const name = path.split("/").pop() ?? path;
+      const entry: FileEntry = { name: path, type: SOURCE_EXTS.test(name) ? "file" : "other" };
+
+      if (SOURCE_EXTS.test(name)) {
+        source.push(entry);
+      } else {
+        other.push(entry);
+      }
+    }
+
+    const filtered: { count: number; reason: string }[] = [];
+    if (nodeModulesCount > 0) filtered.push({ count: nodeModulesCount, reason: "node_modules" });
+    if (distCount > 0) filtered.push({ count: distCount, reason: "dist/build" });
+
+    return {
+      total: lines.length,
+      source,
+      other,
+      filtered,
+    };
+  },
+};

package/src/parsers/git.ts

@@ -0,0 +1,86 @@
+// Parsers for git output (log, status, diff)
+
+import type { Parser, GitLogEntry, GitStatus } from "./base.js";
+
+export const gitLogParser: Parser<GitLogEntry[]> = {
+  name: "git-log",
+
+  detect(command: string, _output: string): boolean {
+    return /\bgit\s+log\b/.test(command);
+  },
+
+  parse(_command: string, output: string): GitLogEntry[] {
+    const entries: GitLogEntry[] = [];
+    const lines = output.split("\n");
+
+    let hash = "", author = "", date = "", message: string[] = [];
+
+    for (const line of lines) {
+      const commitMatch = line.match(/^commit\s+([a-f0-9]+)/);
+      if (commitMatch) {
+        if (hash) {
+          entries.push({ hash: hash.slice(0, 8), author, date, message: message.join(" ").trim() });
+        }
+        hash = commitMatch[1];
+        author = ""; date = ""; message = [];
+        continue;
+      }
+
+      const authorMatch = line.match(/^Author:\s+(.+)/);
+      if (authorMatch) { author = authorMatch[1]; continue; }
+
+      const dateMatch = line.match(/^Date:\s+(.+)/);
+      if (dateMatch) { date = dateMatch[1].trim(); continue; }
+
+      if (line.startsWith("    ")) {
+        message.push(line.trim());
+      }
+    }
+
+    if (hash) {
+      entries.push({ hash: hash.slice(0, 8), author, date, message: message.join(" ").trim() });
+    }
+
+    return entries;
+  },
+};
+
+export const gitStatusParser: Parser<GitStatus> = {
+  name: "git-status",
+
+  detect(command: string, _output: string): boolean {
+    return /\bgit\s+status\b/.test(command);
+  },
+
+  parse(_command: string, output: string): GitStatus {
+    const lines = output.split("\n");
+    let branch = "";
+    const staged: string[] = [];
+    const unstaged: string[] = [];
+    const untracked: string[] = [];
+
+    const branchMatch = output.match(/On branch\s+(\S+)/);
+    if (branchMatch) branch = branchMatch[1];
+
+    let section = "";
+    for (const line of lines) {
+      if (line.includes("Changes to be committed")) { section = "staged"; continue; }
+      if (line.includes("Changes not staged")) { section = "unstaged"; continue; }
+      if (line.includes("Untracked files")) { section = "untracked"; continue; }
+
+      const fileMatch = line.match(/^\s+(?:new file|modified|deleted|renamed):\s+(.+)/);
+      if (fileMatch) {
+        if (section === "staged") staged.push(fileMatch[1].trim());
+        else if (section === "unstaged") unstaged.push(fileMatch[1].trim());
+        continue;
+      }
+
+      // Untracked files are just indented filenames
+      if (section === "untracked" && line.match(/^\s+\S/) && !line.includes("(use ")) {
+        untracked.push(line.trim());
+      }
+    }
+
+    return { branch, staged, unstaged, untracked };
+  },
+};

package/src/parsers/index.ts

@@ -0,0 +1,66 @@
+// Output parser registry — auto-detect command output type and parse to structured JSON
+
+import type { Parser } from "./base.js";
+import { lsParser, findParser } from "./files.js";
+import { testParser } from "./tests.js";
+import { gitLogParser, gitStatusParser } from "./git.js";
+import { buildParser, npmInstallParser } from "./build.js";
+import { errorParser } from "./errors.js";
+
+export type { Parser } from "./base.js";
+export type {
+  FileEntry, TestResult, GitLogEntry, GitStatus,
+  BuildResult, NpmInstallResult, ErrorInfo, SearchResult,
+} from "./base.js";
+
+// Ordered by specificity — more specific parsers first
+const parsers: Parser[] = [
+  npmInstallParser,
+  testParser,
+  gitLogParser,
+  gitStatusParser,
+  buildParser,
+  findParser,
+  lsParser,
+  errorParser, // fallback for error detection
+];
+
+export interface ParseResult {
+  parser: string;
+  data: unknown;
+  raw: string;
+}
+
+/** Try to parse command output with the best matching parser */
+export function parseOutput(command: string, output: string): ParseResult | null {
+  for (const parser of parsers) {
+    if (parser.detect(command, output)) {
+      try {
+        const data = parser.parse(command, output);
+        return { parser: parser.name, data, raw: output };
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+
+/** Get all parsers that match (for debugging/info) */
+export function detectParsers(command: string, output: string): string[] {
+  return parsers.filter(p => p.detect(command, output)).map(p => p.name);
+}
+
+/** Estimate token count for a string (rough: ~4 chars per token) */
+export function estimateTokens(text: string): number {
+  return Math.ceil(text.length / 4);
+}
+
+/** Calculate token savings between raw output and parsed JSON */
+export function tokenSavings(raw: string, parsed: unknown): { rawTokens: number; parsedTokens: number; saved: number; percent: number } {
+  const rawTokens = estimateTokens(raw);
+  const parsedTokens = estimateTokens(JSON.stringify(parsed));
+  const saved = Math.max(0, rawTokens - parsedTokens);
+  const percent = rawTokens > 0 ? Math.round((saved / rawTokens) * 100) : 0;
+  return { rawTokens, parsedTokens, saved, percent };
+}

package/src/parsers/parsers.test.ts

@@ -0,0 +1,153 @@
+import { describe, it, expect } from "bun:test";
+import { parseOutput, tokenSavings, estimateTokens } from "./index.js";
+
+describe("parseOutput", () => {
+  it("parses ls -la output", () => {
+    const output = `total 32
+drwxr-xr-x  5 user staff  160 Mar 10 09:00 src
+-rw-r--r--  1 user staff  450 Mar 10 09:00 package.json
+lrwxr-xr-x  1 user staff   20 Mar 10 09:00 link -> target`;
+
+    const result = parseOutput("ls -la", output);
+    expect(result).not.toBeNull();
+    expect(result!.parser).toBe("ls");
+    const data = result!.data as any[];
+    expect(data.length).toBe(3);
+    expect(data[0].name).toBe("src");
+    expect(data[0].type).toBe("dir");
+    expect(data[1].name).toBe("package.json");
+    expect(data[1].type).toBe("file");
+    expect(data[2].type).toBe("symlink");
+  });
+
+  it("parses find output and filters node_modules", () => {
+    const output = `./src/lib/webhooks.ts
+./node_modules/@types/node/async_hooks.d.ts
+./node_modules/@types/node/perf_hooks.d.ts
+./dist/lib/webhooks.d.ts
+./src/routes/api.ts`;
+
+    const result = parseOutput("find . -name '*hooks*' -type f", output);
+    expect(result).not.toBeNull();
+    expect(result!.parser).toBe("find");
+    const data = result!.data as any;
+    expect(data.source.length).toBe(2); // webhooks.ts and api.ts
+    expect(data.filtered.length).toBeGreaterThan(0);
+    expect(data.filtered.find((f: any) => f.reason === "node_modules")?.count).toBe(2);
+  });
+
+  it("parses test output (jest style)", () => {
+    const output = `PASS src/auth.test.ts
+FAIL src/db.test.ts
+  ✗ should connect to database
+    Error: Connection refused
+Tests: 5 passed, 1 failed, 1 skipped, 7 total
+Time: 3.2s`;
+
+    const result = parseOutput("npm test", output);
+    expect(result).not.toBeNull();
+    expect(result!.parser).toBe("test");
+    const data = result!.data as any;
+    expect(data.passed).toBe(5);
+    expect(data.failed).toBe(1);
+    expect(data.skipped).toBe(1);
+    expect(data.total).toBe(7);
+  });
+
+  it("parses git status", () => {
+    const output = `On branch main
+Changes to be committed:
+  new file:   src/mcp/server.ts
+  modified:   src/ai.ts
+
+Changes not staged for commit:
+  modified:   package.json
+
+Untracked files:
+  src/tree.ts`;
+
+    const result = parseOutput("git status", output);
+    expect(result).not.toBeNull();
+    expect(result!.parser).toBe("git-status");
+    const data = result!.data as any;
+    expect(data.branch).toBe("main");
+    expect(data.staged.length).toBe(2);
+    expect(data.unstaged.length).toBe(1);
+    expect(data.untracked.length).toBe(1);
+  });
+
+  it("parses git log", () => {
+    const output = `commit af19ce3456789
+Author: Andrei Hasna <andrei@hasna.com>
+Date:   Sat Mar 15 10:00:00 2026
+
+    feat: add MCP server
+
+commit 3963db5123456
+Author: Andrei Hasna <andrei@hasna.com>
+Date:   Fri Mar 14 09:00:00 2026
+
+    feat: tabs and browse mode`;
+
+    const result = parseOutput("git log", output);
+    expect(result).not.toBeNull();
+    expect(result!.parser).toBe("git-log");
+    const data = result!.data as any[];
+    expect(data.length).toBe(2);
+    expect(data[0].hash).toBe("af19ce34");
+    expect(data[0].message).toBe("feat: add MCP server");
+  });
+
+  it("parses npm install output", () => {
+    const output = `added 47 packages in 3.2s
+2 vulnerabilities found`;
+
+    const result = parseOutput("npm install", output);
+    expect(result).not.toBeNull();
+    expect(result!.parser).toBe("npm-install");
+    const data = result!.data as any;
+    expect(data.installed).toBe(47);
+    expect(data.duration).toBe("3.2s");
+    expect(data.vulnerabilities).toBe(2);
+  });
+
+  it("parses build output", () => {
+    const output = `Compiling...
+1 warning
+Found 0 errors
+Done in 2.5s`;
+
+    const result = parseOutput("npm run build", output);
+    expect(result).not.toBeNull();
+    expect(result!.parser).toBe("build");
+    const data = result!.data as any;
+    expect(data.status).toBe("success");
+    expect(data.warnings).toBe(1);
+  });
+
+  it("detects errors", () => {
+    const output = `Error: EADDRINUSE: address already in use :3000`;
+    const result = parseOutput("node server.js", output);
+    expect(result).not.toBeNull();
+    expect(result!.parser).toBe("error");
+    const data = result!.data as any;
+    expect(data.type).toBe("port_in_use");
+  });
+});
+
+describe("estimateTokens", () => {
+  it("estimates roughly 4 chars per token", () => {
+    expect(estimateTokens("hello world")).toBe(3); // 11 chars / 4 = 2.75 → 3
+  });
+});
+
+describe("tokenSavings", () => {
+  it("calculates savings correctly", () => {
+    const raw = "a".repeat(400); // 100 tokens
+    const parsed = { status: "ok" };
+    const result = tokenSavings(raw, parsed);
+    expect(result.rawTokens).toBe(100);
+    expect(result.saved).toBeGreaterThan(0);
+    expect(result.percent).toBeGreaterThan(0);
+  });
+});

package/src/parsers/tests.ts

@@ -0,0 +1,98 @@
+// Parser for test runner output (jest, vitest, bun test, pytest, go test)
+
+import type { Parser, TestResult } from "./base.js";
+
+export const testParser: Parser<TestResult> = {
+  name: "test",
+
+  detect(command: string, output: string): boolean {
+    if (/\b(jest|vitest|bun\s+test|pytest|go\s+test|mocha|ava|tap)\b/.test(command)) return true;
+    if (/\b(npm|bun|pnpm|yarn)\s+(run\s+)?test\b/.test(command)) return true;
+    // Detect by output patterns
+    return /Tests:\s+\d+/.test(output) || /\d+\s+(passing|passed|failed)/.test(output) || /PASS|FAIL/.test(output);
+  },
+
+  parse(_command: string, output: string): TestResult {
+    const failures: { test: string; error: string }[] = [];
+    let passed = 0, failed = 0, skipped = 0, duration: string | undefined;
+
+    // Jest/Vitest style: Tests: 5 passed, 2 failed, 7 total
+    const jestMatch = output.match(/Tests:\s+(?:(\d+)\s+passed)?[,\s]*(?:(\d+)\s+failed)?[,\s]*(?:(\d+)\s+skipped)?[,\s]*(\d+)\s+total/);
+    if (jestMatch) {
+      passed = parseInt(jestMatch[1] ?? "0");
+      failed = parseInt(jestMatch[2] ?? "0");
+      skipped = parseInt(jestMatch[3] ?? "0");
+    }
+
+    // Bun test style: 5 pass, 2 fail
+    const bunMatch = output.match(/(\d+)\s+pass.*?(\d+)\s+fail/);
+    if (!jestMatch && bunMatch) {
+      passed = parseInt(bunMatch[1]);
+      failed = parseInt(bunMatch[2]);
+    }
+
+    // Pytest style: 5 passed, 2 failed
+    const pytestMatch = output.match(/(\d+)\s+passed(?:.*?(\d+)\s+failed)?/);
+    if (!jestMatch && !bunMatch && pytestMatch) {
+      passed = parseInt(pytestMatch[1]);
+      failed = parseInt(pytestMatch[2] ?? "0");
+    }
+
+    // Go test: ok/FAIL + count
+    const goPassMatch = output.match(/ok\s+\S+\s+([\d.]+s)/);
+    const goFailMatch = output.match(/FAIL\s+\S+/);
+    if (!jestMatch && !bunMatch && !pytestMatch && (goPassMatch || goFailMatch)) {
+      const passLines = (output.match(/--- PASS/g) || []).length;
+      const failLines = (output.match(/--- FAIL/g) || []).length;
+      passed = passLines;
+      failed = failLines;
+      if (goPassMatch) duration = goPassMatch[1];
+    }
+
+    // Duration
+    const timeMatch = output.match(/Time:\s+([\d.]+\s*(?:s|ms|m))/i) || output.match(/in\s+([\d.]+\s*(?:s|ms|m))/i);
+    if (timeMatch) duration = timeMatch[1];
+
+    // Extract failure details: lines starting with FAIL or ✗ or ×
+    const lines = output.split("\n");
+    let capturingFailure = false;
+    let currentTest = "";
+    let currentError: string[] = [];
+
+    for (const line of lines) {
+      const failMatch = line.match(/(?:FAIL|✗|×|✕)\s+(.+)/);
+      if (failMatch) {
+        if (capturingFailure && currentTest) {
+          failures.push({ test: currentTest, error: currentError.join("\n").trim() });
+        }
+        currentTest = failMatch[1].trim();
+        currentError = [];
+        capturingFailure = true;
+        continue;
+      }
+
+      if (capturingFailure) {
+        if (line.match(/^(PASS|✓|✔|FAIL|✗|×|✕)\s/) || line.match(/^Tests:|^\d+ pass/)) {
+          failures.push({ test: currentTest, error: currentError.join("\n").trim() });
+          capturingFailure = false;
+          currentTest = "";
+          currentError = [];
+        } else {
+          currentError.push(line);
+        }
+      }
+    }
+    if (capturingFailure && currentTest) {
+      failures.push({ test: currentTest, error: currentError.join("\n").trim() });
+    }
+
+    return {
+      passed,
+      failed,
+      skipped,
+      total: passed + failed + skipped,
+      duration,
+      failures,
+    };
+  },
+};

package/src/providers/anthropic.ts

@@ -0,0 +1,44 @@
+import Anthropic from "@anthropic-ai/sdk";
+import type { LLMProvider, ProviderOptions, StreamCallbacks } from "./base.js";
+
+export class AnthropicProvider implements LLMProvider {
+  readonly name = "anthropic";
+  private client: Anthropic;
+
+  constructor() {
+    this.client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+  }
+
+  isAvailable(): boolean {
+    return !!process.env.ANTHROPIC_API_KEY;
+  }
+
+  async complete(prompt: string, options: ProviderOptions): Promise<string> {
+    const message = await this.client.messages.create({
+      model: options.model ?? "claude-haiku-4-5-20251001",
+      max_tokens: options.maxTokens ?? 256,
+      system: options.system,
+      messages: [{ role: "user", content: prompt }],
+    });
+    const block = message.content[0];
+    if (block.type !== "text") throw new Error("Unexpected response type");
+    return block.text.trim();
+  }
+
+  async stream(prompt: string, options: ProviderOptions, callbacks: StreamCallbacks): Promise<string> {
+    let result = "";
+    const stream = await this.client.messages.stream({
+      model: options.model ?? "claude-haiku-4-5-20251001",
+      max_tokens: options.maxTokens ?? 256,
+      system: options.system,
+      messages: [{ role: "user", content: prompt }],
+    });
+    for await (const chunk of stream) {
+      if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
+        result += chunk.delta.text;
+        callbacks.onToken(result.trim());
+      }
+    }
+    return result.trim();
+  }
+}

package/src/providers/base.ts

@@ -0,0 +1,34 @@
+// Provider interface for LLM backends (Anthropic, Cerebras, etc.)
+
+export interface ProviderOptions {
+  model?: string;
+  maxTokens?: number;
+  system: string;
+}
+
+export interface StreamCallbacks {
+  onToken: (partial: string) => void;
+}
+
+export interface LLMProvider {
+  readonly name: string;
+
+  /** Generate a completion (non-streaming) */
+  complete(prompt: string, options: ProviderOptions): Promise<string>;
+
+  /** Generate a completion with streaming */
+  stream(prompt: string, options: ProviderOptions, callbacks: StreamCallbacks): Promise<string>;
+
+  /** Check if the provider is available (has API key, etc.) */
+  isAvailable(): boolean;
+}
+
+export interface ProviderConfig {
+  provider: "cerebras" | "anthropic" | "auto";
+  cerebrasModel?: string;
+  anthropicModel?: string;
+}
+
+export const DEFAULT_PROVIDER_CONFIG: ProviderConfig = {
+  provider: "auto",
+};