@yukino.js/yukino 0.0.1

package/dist/lib/chunk-6OMQD7MK.js

@@ -0,0 +1,591 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/logger/index.ts
+var logger_exports = {};
+__export(logger_exports, {
+  closeLogger: () => closeLogger,
+  createChildLogger: () => createChildLogger,
+  initLogger: () => initLogger,
+  logger: () => logger,
+  sanitizeNameSegment: () => sanitizeNameSegment
+});
+import { openSync, closeSync, mkdirSync, writeFileSync } from "fs";
+import { readdir, stat, unlink } from "fs/promises";
+import { homedir } from "os";
+import { join, dirname, basename } from "path";
+import pino from "pino";
+var currentLogger = null;
+var currentDest = null;
+var currentFd = null;
+function resolveLogPath(opts) {
+  const dir = opts.logDir ?? join(opts.workDir ?? process.cwd(), ".yukino", "logs");
+  return join(dir, `${opts.sessionId}.jsonl`);
+}
+function ensureYukinoGitignore(logPath) {
+  let dir = dirname(logPath);
+  while (basename(dir) !== ".yukino") {
+    const parent = dirname(dir);
+    if (parent === dir) {
+      return;
+    }
+    dir = parent;
+  }
+  try {
+    writeFileSync(join(dir, ".gitignore"), "*\n", { flag: "wx" });
+  } catch {
+  }
+}
+function sanitizeNameSegment(name) {
+  const cleaned = name.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return cleaned || "unnamed";
+}
+function flushDestination(dest) {
+  if (typeof dest !== "object" || dest === null) {
+    return;
+  }
+  const fn = Reflect.get(dest, "flushSync");
+  if (typeof fn === "function") {
+    fn.call(dest);
+  }
+}
+var LOG_LEVEL = "warn";
+function initLogger(opts) {
+  if (currentLogger) {
+    closeLogger();
+  }
+  const logPath = resolveLogPath(opts);
+  mkdirSync(dirname(logPath), { recursive: true });
+  ensureYukinoGitignore(logPath);
+  const fd = openSync(logPath, "a");
+  currentFd = fd;
+  currentDest = pino.destination(fd);
+  const pinoOpts = {
+    level: LOG_LEVEL,
+    base: { sessionId: opts.sessionId, mode: opts.mode },
+    serializers: { err: errSerializer }
+  };
+  if (opts.stdout) {
+    currentLogger = pino(
+      pinoOpts,
+      pino.multistream([
+        { stream: currentDest, level: LOG_LEVEL },
+        { stream: process.stdout, level: LOG_LEVEL }
+      ])
+    );
+  } else {
+    currentLogger = pino(pinoOpts, currentDest);
+  }
+  if (!opts.skipCleanup) {
+    const workDir = opts.workDir ?? process.cwd();
+    void cleanExpiredLogs(workDir).catch(() => {
+    });
+  }
+  return currentLogger;
+}
+function getLogger() {
+  return currentLogger;
+}
+function closeLogger() {
+  if (currentLogger) {
+    try {
+      currentLogger.flush();
+    } catch {
+    }
+    currentLogger = null;
+  }
+  if (currentDest) {
+    flushDestination(currentDest);
+    currentDest = null;
+  }
+  if (currentFd !== null) {
+    try {
+      closeSync(currentFd);
+    } catch {
+    }
+    currentFd = null;
+  }
+}
+var silentFallback = pino({ level: "silent" });
+var logger = new Proxy(silentFallback, {
+  get(_target, prop, receiver) {
+    const current = getLogger();
+    const target = current ?? _target;
+    const value = Reflect.get(target, prop, receiver);
+    if (typeof value === "function") {
+      return value.bind(target);
+    }
+    return value;
+  },
+  set(_target, prop, value) {
+    return Reflect.set(getLogger() ?? _target, prop, value);
+  }
+});
+function createChildLogger(bindings) {
+  let cachedChild = null;
+  let cachedLogger = null;
+  const resolveChild = () => {
+    const current = getLogger();
+    if (!current) {
+      return null;
+    }
+    if (cachedChild === null || cachedLogger !== current) {
+      cachedChild = current.child(bindings);
+      cachedLogger = current;
+    }
+    return cachedChild;
+  };
+  return new Proxy(silentFallback, {
+    get(_target, prop, receiver) {
+      const target = resolveChild() ?? _target;
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") {
+        return value.bind(target);
+      }
+      return value;
+    },
+    set(_target, prop, value) {
+      return Reflect.set(resolveChild() ?? _target, prop, value);
+    }
+  });
+}
+async function cleanDir(dir) {
+  let files;
+  try {
+    files = (await readdir(dir)).filter((f) => f.endsWith(".jsonl"));
+  } catch {
+    return 0;
+  }
+  const now = Date.now();
+  let removed = 0;
+  for (const file of files) {
+    const filePath = join(dir, file);
+    try {
+      const s = await stat(filePath);
+      if (now - s.mtimeMs > 30 * 24 * 60 * 60 * 1e3) {
+        await unlink(filePath);
+        removed++;
+      }
+    } catch {
+    }
+  }
+  return removed;
+}
+async function cleanExpiredLogs(workDir) {
+  let removed = 0;
+  removed += await cleanDir(join(workDir, ".yukino", "logs"));
+  const teamsDir = join(homedir(), ".yukino", "teams");
+  let teams;
+  try {
+    teams = await readdir(teamsDir);
+  } catch {
+    return removed;
+  }
+  for (const team of teams) {
+    removed += await cleanDir(join(teamsDir, team, "logs"));
+  }
+  return removed;
+}
+var CAUSE_MAX_DEPTH = 5;
+var RESERVED_KEYS = /* @__PURE__ */ new Set(["name", "message", "stack", "cause"]);
+function serializeErrorInstance(err, depth) {
+  const out = {
+    type: err.name,
+    message: err.message,
+    stack: err.stack
+  };
+  const causeDescriptor = Object.getOwnPropertyDescriptor(err, "cause");
+  if (causeDescriptor && depth < CAUSE_MAX_DEPTH) {
+    const cause = causeDescriptor.value;
+    if (cause instanceof Error) {
+      out.cause = serializeErrorInstance(cause, depth + 1);
+    } else if (cause !== void 0) {
+      out.cause = { message: safeStringify(cause) };
+    }
+  }
+  for (const key of Object.keys(err)) {
+    if (RESERVED_KEYS.has(key)) {
+      continue;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(err, key);
+    if (descriptor) {
+      const fieldValue = descriptor.value;
+      out[key] = fieldValue;
+    }
+  }
+  return out;
+}
+function safeStringify(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    const json = JSON.stringify(value);
+    if (json !== void 0) {
+      return json;
+    }
+  } catch {
+  }
+  try {
+    return String(value);
+  } catch {
+    return Object.prototype.toString.call(value);
+  }
+}
+function errSerializer(err) {
+  if (err instanceof Error) {
+    return serializeErrorInstance(err, 0);
+  }
+  return { message: safeStringify(err), value: err };
+}
+
+// src/utils/paths.ts
+var paths_exports = {};
+__export(paths_exports, {
+  canonicalPath: () => canonicalPath,
+  compactPath: () => compactPath,
+  isPathWithin: () => isPathWithin
+});
+import { realpathSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { basename as basename2, dirname as dirname2, isAbsolute, join as join2, relative, resolve, sep } from "path";
+function canonicalPath(path) {
+  let current = resolve(path);
+  const missing = [];
+  for (; ; ) {
+    try {
+      return join2(realpathSync(current), ...missing);
+    } catch (error) {
+      if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT" && error.code !== "ENOTDIR") {
+        throw error;
+      }
+      const parent = dirname2(current);
+      if (parent === current) {
+        return resolve(path);
+      }
+      missing.unshift(basename2(current));
+      current = parent;
+    }
+  }
+}
+function isPathWithin(root, path) {
+  const child = relative(root, path);
+  return child === "" || child !== ".." && !child.startsWith(`..${sep}`) && !isAbsolute(child);
+}
+function compactPath(path) {
+  const home = homedir2();
+  return path === home ? "~" : path.startsWith(`${home}/`) ? `~/${path.slice(home.length + 1)}` : path;
+}
+
+// src/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  Paths: () => paths_exports,
+  Verbs: () => verbs_exports,
+  asError: () => asError,
+  asErrorString: () => asErrorString,
+  asRecord: () => asRecord,
+  asString: () => asString,
+  boolArg: () => boolArg,
+  contentToText: () => contentToText,
+  formatToolArgs: () => formatToolArgs,
+  intArg: () => intArg,
+  isObject: () => isObject,
+  isRecord: () => isRecord,
+  safeJSONParse: () => safeJSONParse,
+  strArg: () => strArg,
+  strList: () => strList,
+  toTry: () => toTry
+});
+
+// src/utils/verbs.ts
+var verbs_exports = {};
+__export(verbs_exports, {
+  randomCompletionVerb: () => randomCompletionVerb,
+  randomVerb: () => randomVerb
+});
+var spinnerVerbs = [
+  "Accomplishing",
+  "Architecting",
+  "Baking",
+  "Barking",
+  "Woofing",
+  "Howling",
+  "Be-bopping'",
+  "Befuddling",
+  "Boogieing",
+  "Boondoggling",
+  "Bootstrapping",
+  "Brewing",
+  "Calculating",
+  "Canoodling",
+  "Caramelizing",
+  "Cascading",
+  "Cerebrating",
+  "Choreographing",
+  "Churning",
+  "Coalescing",
+  "Cogitating",
+  "Combobulating",
+  "Composing",
+  "Computing",
+  "Concocting",
+  "Considering",
+  "Contemplating",
+  "Cooking",
+  "Crafting",
+  "Creating",
+  "Crunching",
+  "Crystallizing",
+  "Cultivating",
+  "Deciphering",
+  "Deliberating",
+  "Dilly-dallying",
+  "Discombobulating",
+  "Doodling",
+  "Elucidating",
+  "Enchanting",
+  "Envisioning",
+  "Fermenting",
+  "Finagling",
+  "Flamb\xE9ing",
+  "Flummoxing",
+  "Forging",
+  "Frolicking",
+  "Gallivanting",
+  "Garnishing",
+  "Generating",
+  "Germinating",
+  "Grooving",
+  "Harmonizing",
+  "Hatching",
+  "Honking",
+  "Ideating",
+  "Imagining",
+  "Improvising",
+  "Incubating",
+  "Inferring",
+  "Infusing",
+  "Kneading",
+  "Lollygagging",
+  "Manifesting",
+  "Marinating",
+  "Meandering",
+  "Metamorphosing",
+  "Mewing",
+  "Moonwalking",
+  "Moseying",
+  "Mulling",
+  "Musing",
+  "Noodling",
+  "Orbiting",
+  "Orchestrating",
+  "Percolating",
+  "Philosophizing",
+  "Pondering",
+  "Pontificating",
+  "Pouncing",
+  "Purring",
+  "Puzzling",
+  "Razzle-dazzling",
+  "Ruminating",
+  "Scampering",
+  "Simmering",
+  "Sketching",
+  "Spelunking",
+  "Spinning",
+  "Sprouting",
+  "Synthesizing",
+  "Thinking",
+  "Tinkering",
+  "Transfiguring",
+  "Transmuting",
+  "Undulating",
+  "Unfurling",
+  "Unravelling",
+  "Vibing",
+  "Wandering",
+  "Whisking",
+  "Working",
+  "Wrangling",
+  "Zigzagging"
+];
+function randomVerb() {
+  return spinnerVerbs[Math.floor(Math.random() * spinnerVerbs.length)];
+}
+var completionVerbs = [
+  "Accomplished",
+  "Baked",
+  "Brewed",
+  "Cooked",
+  "Crafted",
+  "Crunched",
+  "Forged",
+  "Hatched",
+  "Pondered",
+  "Synthesized",
+  "Tinkered",
+  "Worked",
+  "Wrangled",
+  "Computed",
+  "Created",
+  "Composed",
+  "Conjured",
+  "Concocted",
+  "Cultivated",
+  "Deciphered"
+];
+function randomCompletionVerb() {
+  return completionVerbs[Math.floor(Math.random() * completionVerbs.length)];
+}
+
+// src/utils/index.ts
+var log = createChildLogger({ module: "utils" });
+function contentToText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  const parts = [];
+  for (const block of content) {
+    if (block.type === "text" && typeof block.text === "string") {
+      parts.push(block.text);
+    } else if (block.type === "image" && isRecord(block.source)) {
+      const mediaType = block.source.type === "base64" && typeof block.source.media_type === "string" ? block.source.media_type : "image";
+      parts.push(`[Image: ${mediaType}]`);
+    } else if (block.type === "tool_reference" && typeof block.tool_name === "string") {
+      parts.push(`[Tool reference: ${block.tool_name}]`);
+    } else if (block.type === "search_result") {
+      const title = typeof block.title === "string" ? block.title : "search result";
+      const source = typeof block.source === "string" ? ` (${block.source})` : "";
+      const nested = Array.isArray(block.content) ? contentToText(block.content.filter(isRecord)) : "";
+      parts.push(`${title}${source}${nested ? `
+${nested}` : ""}`);
+    } else if (block.type === "document") {
+      const title = typeof block.title === "string" ? block.title : "document";
+      parts.push(`[Document: ${title}]`);
+    }
+  }
+  return parts.join("\n");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asRecord(value) {
+  if (isRecord(value)) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return Object.fromEntries(value.entries());
+  }
+  return {};
+}
+function asString(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return String(value);
+}
+function asErrorString(value) {
+  if (value instanceof Error) {
+    return value.message;
+  }
+  return asString(value);
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function toTry(fn, ctx) {
+  if (typeof fn !== "function") {
+    return fn;
+  }
+  return function(...args) {
+    let ret;
+    try {
+      ret = ctx ? fn.call(ctx, ...args) : fn.call(this, ...args);
+    } catch (err) {
+      log.error({ err }, "utils operation failed");
+      return void 0;
+    }
+    return ret;
+  };
+}
+var safeJSONParse = toTry(JSON.parse, JSON);
+function asError(err) {
+  if (err instanceof Error) {
+    return err;
+  }
+  return new Error(String(err));
+}
+function intArg(args, key, fallback) {
+  const v = args[key];
+  if (typeof v === "number") {
+    return Math.floor(v);
+  }
+  if (typeof v === "string") {
+    const n = Number.parseInt(v, 10);
+    return Number.isNaN(n) ? fallback : n;
+  }
+  return fallback;
+}
+function strList(raw) {
+  if (Array.isArray(raw)) {
+    return raw.filter((v) => typeof v === "string");
+  }
+  return [];
+}
+function strArg(args, key, fallback) {
+  const v = args[key];
+  if (typeof v === "string") {
+    return v;
+  }
+  return fallback ?? "";
+}
+function boolArg(args, key, fallback) {
+  const v = args[key];
+  if (typeof v === "boolean") {
+    return v;
+  }
+  return fallback ?? Boolean(v);
+}
+function formatToolArgs(args) {
+  if (args.command) {
+    return truncate(strArg(args, "command"), 80);
+  }
+  if (args.file_path) {
+    return truncate(strArg(args, "file_path"), 80);
+  }
+  if (args.pattern) {
+    return truncate(strArg(args, "pattern"), 80);
+  }
+  if (args.description) {
+    return truncate(strArg(args, "description"), 80);
+  }
+  return "";
+}
+function truncate(value, max) {
+  return value.length > max ? `${value.slice(0, max)}\u2026` : value;
+}
+
+export {
+  sanitizeNameSegment,
+  initLogger,
+  closeLogger,
+  logger,
+  createChildLogger,
+  logger_exports,
+  canonicalPath,
+  isPathWithin,
+  randomVerb,
+  contentToText,
+  isRecord,
+  asRecord,
+  asString,
+  asErrorString,
+  isObject,
+  intArg,
+  strList,
+  strArg,
+  boolArg,
+  utils_exports
+};