agentlas 0.4.0

package/engine/agentlas-style.cjs

@@ -0,0 +1,100 @@
+"use strict";
+
+/*
+ * Global terminal reply style for Agentlas.
+ *
+ * This is intentionally kept outside individual agent prompts so imported,
+ * cloud-installed, company, native-CLI, and BYOK agents all share one contract.
+ */
+
+function detectResponseLanguage(prompt, fallback) {
+  const text = String(prompt || "");
+  if (/\b(answer|reply|respond|write)\s+in\s+(english|en)\b/i.test(text)) return "en";
+  if (/(영어로|영문으로|english로)/i.test(text)) return "en";
+  if (/(한국어로|한글로|한글\s*답|korean으로)/i.test(text)) return "ko";
+  const hangul = (text.match(/[가-힣]/g) || []).length;
+  const latin = (text.match(/[A-Za-z]/g) || []).length;
+  if (hangul >= 2 && hangul >= latin * 0.15) return "ko";
+  if (latin >= 2 && hangul === 0) return "en";
+  return fallback === "ko" ? "ko" : "en";
+}
+
+function responseLanguageDirective(lang) {
+  return lang === "ko"
+    ? [
+        "응답 언어: 한국어.",
+        "이번 사용자 메시지가 다른 언어를 명시적으로 요구하지 않는 한 한국어만 사용하세요.",
+        "제품명, 명령어, 파일 경로, 코드 식별자처럼 번역하면 안 되는 고유명사만 원문을 유지하세요.",
+        "한 문단 안에서 한국어와 영어 설명을 섞지 마세요.",
+      ].join("\n")
+    : [
+        "Response language: English.",
+        "Use English only unless this user message explicitly asks for another language.",
+        "Keep product names, commands, file paths, and code identifiers unchanged.",
+        "Do not mix Korean and English explanatory prose in the same reply.",
+      ].join("\n");
+}
+
+function responseStyleDirective() {
+  return [
+    "Global Agentlas reply style:",
+    "Use normal Markdown when it aids clarity — **bold** for emphasis, `code`/code blocks for code,",
+    "paths, and commands, and # headings, - bullets, or 1. numbered lists for structure.",
+    "Keep replies concise; make the first sentence concrete and action-oriented.",
+    "Do not expose hidden chain-of-thought — give the result and a short rationale.",
+  ].join("\n");
+}
+
+function responseDirective(lang) {
+  return responseLanguageDirective(lang) + "\n\n" + responseStyleDirective();
+}
+
+let EMOJI_RE = null;
+try {
+  EMOJI_RE = new RegExp("[\\p{Extended_Pictographic}\\uFE0F\\u200D]+", "gu");
+} catch {
+  EMOJI_RE = /[\u2600-\u27BF\uD83C-\uDBFF\uDC00-\uDFFF]/g;
+}
+
+function sanitizeAssistantText(text) {
+  return String(text || "")
+    .replace(EMOJI_RE, "")
+    .replace(/\*\*/g, "")
+    .replace(/^\s{0,3}#{1,6}\s*/gm, "")
+    .replace(/^\s{0,3}>\s?/gm, "")
+    .replace(/^\s{0,3}[-*+]\s+/gm, "")
+    .replace(/^\s{0,3}-{3,}\s*$/gm, "")
+    .replace(/[ \t]+[-–—][ \t]+/g, ": ");
+}
+
+function createStreamingSanitizer() {
+  let pending = "";
+  return {
+    reset() {
+      pending = "";
+    },
+    push(chunk) {
+      let value = pending + String(chunk || "");
+      pending = "";
+      if (value.endsWith("*")) {
+        pending = "*";
+        value = value.slice(0, -1);
+      }
+      return sanitizeAssistantText(value);
+    },
+    flush() {
+      const value = sanitizeAssistantText(pending);
+      pending = "";
+      return value;
+    },
+  };
+}
+
+module.exports = {
+  createStreamingSanitizer,
+  detectResponseLanguage,
+  responseDirective,
+  responseLanguageDirective,
+  responseStyleDirective,
+  sanitizeAssistantText,
+};

package/engine/agentlas-tools.cjs

@@ -0,0 +1,196 @@
+"use strict";
+/*
+ * agentlas-tools: BYOK/Ollama 자체 에이전트 루프가 실행하는 로컬 툴.
+ * 권한 모델(read|write|full)을 코드 레벨에서 강제한다 — Claude/Codex의 permission-mode와 동일 의미.
+ *   read  : 읽기 전용 (list_dir, read_file)
+ *   write : + 파일 생성/편집 (write_file, edit_file)
+ *   full  : + 셸 실행 (bash)
+ * 위험 동작이 현재 권한을 넘으면 던지지 않고 에러 문자열을 tool_result로 돌려준다(루프 안전).
+ */
+const path = require("node:path");
+const fs = require("node:fs");
+const { spawnSync } = require("node:child_process");
+
+const PERM_RANK = { read: 0, write: 1, full: 2 };
+
+function resolveIn(cwd, p) {
+  if (!p) return cwd;
+  return path.isAbsolute(p) ? p : path.resolve(cwd, p);
+}
+function truncate(s, n) {
+  s = String(s);
+  return s.length <= n ? s : s.slice(0, n) + `\n…(${s.length - n} chars truncated)`;
+}
+
+const TOOLS = [
+  {
+    name: "list_dir",
+    minPerm: "read",
+    description: "List files and folders in a directory (relative to the working folder).",
+    parameters: {
+      type: "object",
+      properties: { path: { type: "string", description: "Directory path (default: working folder)" } },
+    },
+    run(args, ctx) {
+      const dir = resolveIn(ctx.cwd, args.path || ".");
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      const lines = entries
+        .slice(0, 400)
+        .map((e) => (e.isDirectory() ? e.name + "/" : e.name))
+        .sort();
+      return `${dir}\n` + lines.join("\n");
+    },
+  },
+  {
+    name: "read_file",
+    minPerm: "read",
+    description: "Read a UTF-8 text file. Optionally from a line offset.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+        offset: { type: "number", description: "1-based start line" },
+        limit: { type: "number", description: "max lines" },
+      },
+      required: ["path"],
+    },
+    run(args, ctx) {
+      const file = resolveIn(ctx.cwd, args.path);
+      let content = fs.readFileSync(file, "utf8");
+      if (args.offset || args.limit) {
+        const lines = content.split("\n");
+        const start = Math.max(0, (args.offset || 1) - 1);
+        const end = args.limit ? start + args.limit : lines.length;
+        content = lines.slice(start, end).join("\n");
+      }
+      return truncate(content, 20000);
+    },
+  },
+  {
+    name: "write_file",
+    minPerm: "write",
+    description: "Create or overwrite a file with the given content.",
+    parameters: {
+      type: "object",
+      properties: { path: { type: "string" }, content: { type: "string" } },
+      required: ["path", "content"],
+    },
+    run(args, ctx) {
+      const file = resolveIn(ctx.cwd, args.path);
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      const existed = fs.existsSync(file);
+      fs.writeFileSync(file, args.content, "utf8");
+      return `${existed ? "overwrote" : "created"} ${file} (${args.content.length} bytes)`;
+    },
+  },
+  {
+    name: "edit_file",
+    minPerm: "write",
+    description:
+      "Replace an exact substring in a file. old_string must occur exactly once unless replace_all is true.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+        old_string: { type: "string" },
+        new_string: { type: "string" },
+        replace_all: { type: "boolean" },
+      },
+      required: ["path", "old_string", "new_string"],
+    },
+    run(args, ctx) {
+      if (args.old_string === "") throw new Error("old_string must be non-empty");
+      const file = resolveIn(ctx.cwd, args.path);
+      const src = fs.readFileSync(file, "utf8");
+      if (!src.includes(args.old_string)) throw new Error("old_string not found");
+      const count = src.split(args.old_string).length - 1;
+      if (!args.replace_all && count > 1) throw new Error(`old_string occurs ${count}× (use replace_all or add context)`);
+      const out = args.replace_all
+        ? src.split(args.old_string).join(args.new_string)
+        : src.replace(args.old_string, args.new_string);
+      fs.writeFileSync(file, out, "utf8");
+      return `edited ${file} (${count} replacement${count > 1 ? "s" : ""})`;
+    },
+  },
+  {
+    name: "bash",
+    minPerm: "full",
+    description: "Run a shell command in the working folder. Requires 'full' permission.",
+    parameters: {
+      type: "object",
+      properties: { command: { type: "string" }, timeout_ms: { type: "number" } },
+      required: ["command"],
+    },
+    run(args, ctx) {
+      const t = Number(args.timeout_ms);
+      const timeout = Math.min(Math.max(Number.isFinite(t) && t > 0 ? t : 120000, 1000), 600000);
+      const res = spawnSync("bash", ["-lc", args.command], {
+        cwd: ctx.cwd,
+        encoding: "utf8",
+        timeout,
+        maxBuffer: 8 * 1024 * 1024,
+        env: process.env,
+      });
+      const parts = [];
+      if (res.stdout) parts.push(res.stdout);
+      if (res.stderr) parts.push(res.stderr);
+      // spawnSync는 timeout/maxBuffer/spawn 실패를 status=null + error/signal로 알린다 — 무음 실패 방지.
+      let head = `exit ${res.status == null ? "?" : res.status}`;
+      if (res.error) {
+        head +=
+          res.error.code === "ETIMEDOUT"
+            ? ` (timed out after ${timeout}ms)`
+            : res.error.code === "ENOBUFS"
+              ? " (output exceeded 8MB, truncated)"
+              : ` (spawn error: ${res.error.message})`;
+      } else if (res.signal) {
+        head += ` (killed by ${res.signal})`;
+      }
+      const body = truncate(parts.join("\n").trim() || "(no output)", 12000);
+      return `${head}\n${body}`;
+    },
+  },
+];
+
+const BY_NAME = Object.fromEntries(TOOLS.map((t) => [t.name, t]));
+
+// 현재 권한에서 허용되는 툴만.
+function allowedTools(permission) {
+  const rank = PERM_RANK[permission] ?? 0;
+  return TOOLS.filter((t) => (PERM_RANK[t.minPerm] ?? 0) <= rank);
+}
+
+// 툴 1개 실행 → { ok, content }. 권한 부족/에러는 ok:false 문자열로.
+function runTool(name, args, ctx) {
+  const tool = BY_NAME[name];
+  if (!tool) return { ok: false, content: `unknown tool: ${name}` };
+  const rank = PERM_RANK[ctx.permission] ?? 0;
+  if ((PERM_RANK[tool.minPerm] ?? 0) > rank) {
+    return {
+      ok: false,
+      content: `permission denied: '${name}' requires '${tool.minPerm}' but current is '${ctx.permission}'. Ask the user to run /permission ${tool.minPerm}.`,
+    };
+  }
+  try {
+    return { ok: true, content: String(tool.run(args || {}, ctx)) };
+  } catch (e) {
+    return { ok: false, content: `${name} error: ${e && e.message ? e.message : String(e)}` };
+  }
+}
+
+// ── provider별 tool 선언 포맷 ─────────────────────────────
+function anthropicTools(permission) {
+  return allowedTools(permission).map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.parameters,
+  }));
+}
+function openaiTools(permission) {
+  return allowedTools(permission).map((t) => ({
+    type: "function",
+    function: { name: t.name, description: t.description, parameters: t.parameters },
+  }));
+}
+
+module.exports = { TOOLS, BY_NAME, allowedTools, runTool, anthropicTools, openaiTools, PERM_RANK };

package/engine/agentlas-ui.cjs

@@ -0,0 +1,266 @@
+"use strict";
+/*
+ * Agentlas terminal UI primitives — self-contained, zero-dependency (CJS).
+ *
+ * Electron-as-Node로 실행되므로 외부 컬러 라이브러리(chalk v5 ESM 등)에 의존하지 않는다.
+ * 24-bit truecolor ANSI를 직접 쓰고, NO_COLOR / 비-TTY 환경에서는 평문으로 폴백한다.
+ * 브랜드 팔레트는 보스턴테리어 paw 마크(크림슨) + agentlas-desktop-banner.svg(그린/틸 액센트)에서 가져왔다.
+ */
+
+const i18n = require("./agentlas-i18n.cjs");
+
+const RESET = "\x1b[0m";
+
+function colorEnabled() {
+  if (process.env.NO_COLOR != null && process.env.NO_COLOR !== "") return false;
+  if (process.env.FORCE_COLOR === "1" || process.env.FORCE_COLOR === "true") return true;
+  if (process.env.AGENTLAS_NO_COLOR === "1") return false;
+  return !!process.stdout.isTTY;
+}
+
+// 브랜드 색 (R,G,B). banner.svg / paw mark 기준.
+const BRAND = {
+  paw: [214, 69, 58], // 크림슨 (보스턴테리어 발바닥)
+  pawDim: [138, 45, 38],
+  emerald: [110, 231, 183], // #6EE7B7
+  green: [52, 211, 153], // #34D399
+  lime: [217, 249, 157], // #D9F99D
+  blue: [147, 197, 253], // #93C5FD
+  amber: [251, 191, 36], // #FBBF24
+  pink: [244, 114, 182], // #F472B6
+  text: [229, 231, 235], // #E5E7EB
+  dim: [107, 114, 128], // #6B7280
+  faint: [75, 85, 99],
+};
+
+function makePalette(enabled) {
+  const fg = (rgb) => (s) => (enabled ? `\x1b[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m${s}${RESET}` : String(s));
+  const sgr = (code) => (s) => (enabled ? `\x1b[${code}m${s}${RESET}` : String(s));
+  return {
+    paw: fg(BRAND.paw),
+    pawDim: fg(BRAND.pawDim),
+    emerald: fg(BRAND.emerald),
+    green: fg(BRAND.green),
+    lime: fg(BRAND.lime),
+    blue: fg(BRAND.blue),
+    amber: fg(BRAND.amber),
+    pink: fg(BRAND.pink),
+    text: fg(BRAND.text),
+    dim: fg(BRAND.dim),
+    faint: fg(BRAND.faint),
+    bold: sgr("1"),
+    italic: sgr("3"),
+    underline: sgr("4"),
+    inverse: sgr("7"),
+  };
+}
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+// ANSI 시퀀스를 제거한 가시 폭 (대략) — wide char는 단순 1로 계산(충분).
+function visibleWidth(s) {
+  return stripAnsi(s).length;
+}
+function stripAnsi(s) {
+  // eslint-disable-next-line no-control-regex
+  return String(s).replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+class Ui {
+  constructor(opts = {}) {
+    this.enabled = opts.color != null ? opts.color : colorEnabled();
+    this.c = makePalette(this.enabled);
+    this.out = opts.stream || process.stdout;
+    this.lang = opts.lang || "en";
+    this.t = (key, ...args) => i18n.t(this.lang, key, ...args);
+    this._spinTimer = null;
+    this._spinText = "";
+    this._spinFrame = 0;
+    this._spinStart = 0;
+    this._turnStart = null; // set by beginTurn() so the spinner shows total-turn elapsed
+    this._streaming = false;
+    this._atLineStart = true;
+    this._lastUsage = null; // last per-turn usage (for session /cost ledger)
+  }
+
+  write(s) {
+    this.out.write(s);
+    if (s.length) this._atLineStart = s.endsWith("\n");
+  }
+  line(s = "") {
+    this.stopSpinner();
+    this.write(s + "\n");
+  }
+  // 줄 시작이 아니면 개행을 보장 (스트리밍/스피너 뒤 깔끔한 블록 시작용).
+  ensureNl() {
+    if (!this._atLineStart) this.write("\n");
+  }
+
+  rule(label) {
+    const cols = (this.out.columns || 80);
+    if (label) {
+      const text = ` ${label} `;
+      const dashes = Math.max(0, cols - visibleWidth(text) - 1);
+      this.line(this.c.faint("─") + this.c.dim(text) + this.c.faint("─".repeat(dashes)));
+    } else {
+      this.line(this.c.faint("─".repeat(Math.max(0, cols - 1))));
+    }
+  }
+
+  // ── 스피너 (stderr가 아닌 메인 스트림에, 같은 줄을 갱신) ──
+  startSpinner(text) {
+    if (!this.enabled || !this.out.isTTY) {
+      // 폴백: 한 번만 상태 출력
+      if (text && text !== this._spinText) this.line(this.c.dim("  " + text));
+      this._spinText = text || "";
+      return;
+    }
+    this._spinText = text || "";
+    if (this._spinTimer) return;
+    this._spinStart = Date.now();
+    const tick = () => {
+      const frame = SPINNER_FRAMES[this._spinFrame % SPINNER_FRAMES.length];
+      this._spinFrame++;
+      const start = this._turnStart || this._spinStart;
+      const secs = Math.floor((Date.now() - start) / 1000);
+      // Claude Code 스타일 라이브 메타: 경과초 + 중단 힌트 (1초 이상부터)
+      const meta = secs >= 1 ? this.c.faint(`  (${secs}s · ${this.t ? this.t("spinnerStop") : "ctrl-c to stop"})`) : "";
+      this.out.write("\r\x1b[2K" + this.c.emerald(frame) + " " + this.c.dim(this._spinText) + meta);
+      this._atLineStart = false;
+    };
+    tick();
+    this._spinTimer = setInterval(tick, 120);
+    if (this._spinTimer.unref) this._spinTimer.unref();
+  }
+
+  // 턴 시작/끝 — 스피너가 (툴 사이에 멈췄다 다시 떠도) 총 턴 경과시간을 보여주도록.
+  beginTurn() {
+    this._turnStart = Date.now();
+  }
+  endTurn() {
+    this._turnStart = null;
+  }
+  updateSpinner(text) {
+    this._spinText = text || "";
+    if (!this._spinTimer && this.enabled && this.out.isTTY) this.startSpinner(text);
+  }
+  stopSpinner() {
+    if (this._spinTimer) {
+      clearInterval(this._spinTimer);
+      this._spinTimer = null;
+      this.out.write("\r\x1b[2K");
+      this._atLineStart = true;
+    }
+  }
+
+  // ── 사용자/에이전트 라벨 ──
+  promptLabel(name) {
+    return this.c.paw("▌") + this.c.emerald(" › ");
+  }
+  agentHeader(name) {
+    this.ensureNl();
+    this.line("");
+    this.line(this.c.paw("> ") + this.c.bold(this.c.text(name)));
+  }
+
+  // ── 스트리밍 텍스트 ──
+  streamStart() {
+    this.stopSpinner();
+    this.ensureNl();
+    this._streaming = true;
+  }
+  streamDelta(text) {
+    if (!text) return;
+    this.stopSpinner();
+    this.write(this.c.text(text));
+    this._streaming = true;
+  }
+  streamEnd() {
+    if (this._streaming) {
+      this.ensureNl();
+      this._streaming = false;
+    }
+  }
+
+  // ── 툴 호출/결과 라인 (claude/codex 스타일) ──
+  tool(name, arg) {
+    this.stopSpinner();
+    this.ensureNl();
+    const head = this.c.green("⏺ ") + this.c.bold(this.c.text(name));
+    this.line(arg ? head + "  " + this.c.dim(truncate(String(arg), 200)) : head);
+  }
+  toolResult(text, ok = true) {
+    this.stopSpinner();
+    const body = truncate(String(text || "").trim(), 600);
+    if (!body) {
+      this.line("  " + (ok ? this.c.dim("✓ done") : this.c.paw("✗ error")));
+      return;
+    }
+    const lines = body.split("\n");
+    const marker = ok ? this.c.dim("  └ ") : this.c.paw("  └ ");
+    for (let i = 0; i < lines.length; i++) {
+      this.line((i === 0 ? marker : "    ") + this.c.dim(lines[i]));
+    }
+  }
+
+  status(msg) {
+    this.updateSpinner(msg);
+  }
+  info(msg) {
+    this.line(this.c.dim("  " + msg));
+  }
+  ok(msg) {
+    this.stopSpinner();
+    this.line(this.c.green("✓ ") + this.c.text(msg));
+  }
+  warn(msg) {
+    this.stopSpinner();
+    this.line(this.c.amber("! ") + this.c.text(msg));
+  }
+  error(msg) {
+    this.stopSpinner();
+    this.line(this.c.paw("✗ ") + this.c.text(msg));
+  }
+
+  // 최종 텍스트(비스트리밍 경로)에 가벼운 마크다운 강조 적용 후 출력.
+  markdown(text) {
+    this.stopSpinner();
+    this.ensureNl();
+    for (const raw of String(text).split("\n")) {
+      this.line(this.renderInline(raw));
+    }
+  }
+  renderInline(line) {
+    if (!this.enabled) return line;
+    let s = line;
+    // 헤딩
+    const h = s.match(/^(#{1,6})\s+(.*)$/);
+    if (h) return this.c.bold(this.c.emerald(h[2]));
+    // 인라인 코드 `x`
+    s = s.replace(/`([^`]+)`/g, (_m, g) => this.c.amber(g));
+    // 굵게 **x**
+    s = s.replace(/\*\*([^*]+)\*\*/g, (_m, g) => this.c.bold(g));
+    // 불릿
+    s = s.replace(/^(\s*)([-*])\s+/, (_m, sp) => sp + this.c.emerald("• "));
+    return this.c.text(s);
+  }
+
+  cost(usage) {
+    this._lastUsage = usage || null;
+    if (!usage) return;
+    const bits = [];
+    if (usage.input_tokens != null || usage.output_tokens != null) {
+      bits.push(`${usage.input_tokens ?? "?"}→${usage.output_tokens ?? "?"} tok`);
+    }
+    if (usage.cost_usd != null) bits.push(`$${Number(usage.cost_usd).toFixed(4)}`);
+    if (usage.duration_ms != null) bits.push(`${(usage.duration_ms / 1000).toFixed(1)}s`);
+    if (bits.length) this.line(this.c.faint("  " + bits.join("  ·  ")));
+  }
+}
+
+function truncate(s, n) {
+  if (s.length <= n) return s;
+  return s.slice(0, n) + "…";
+}
+
+module.exports = { Ui, colorEnabled, BRAND, stripAnsi, visibleWidth, truncate, SPINNER_FRAMES };