@swifty.js/swifty 0.0.21 → 0.0.23

package/dist/lib/chunk-CYDNMEBC.js

@@ -0,0 +1,339 @@
+import {
+  createChildLogger
+} from "./chunk-EY7HE52Q.js";
+
+// src/config/config.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { safeParse } from "@modelcontextprotocol/sdk/server/zod-compat.js";
+import yaml from "js-yaml";
+import { z } from "zod";
+var log = createChildLogger({ module: "config" });
+var ENV_KEY_MAP = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  "openai-compat": "OPENAI_API_KEY"
+};
+function isKeyofTypeofEnvKeyMap(k) {
+  return VALID_PROTOCOLS.has(k);
+}
+var VALID_PROTOCOLS = new Set(Object.keys(ENV_KEY_MAP));
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+var ProviderConfigSchema = z.object({
+  name: z.string(),
+  /**
+   * enum: ["anthropic", "openai", "openai-compat"]
+   */
+  protocol: z.enum(["anthropic", "openai", "openai-compat"]),
+  base_url: z.string(),
+  model: z.string(),
+  api_key: z.string().optional(),
+  thinking: z.boolean().optional(),
+  context_window: z.coerce.number().optional(),
+  max_output_tokens: z.coerce.number().optional()
+});
+var MODEL_CONTEXT_WINDOWS = [
+  // 1M-token variants (e.g. "...-1m") come first so they win over the base family.
+  ["1m", 1e6],
+  ["gpt-4.1", 1e6],
+  ["gpt-4o", 128e3],
+  ["gpt-4-turbo", 128e3],
+  ["o1", 2e5],
+  ["o3", 2e5],
+  ["o4", 2e5],
+  ["gpt-3.5", 16385],
+  ["claude", 2e5]
+];
+function lookupModelContextWindow(model) {
+  const model_ = model.toLowerCase();
+  for (const [m, window] of MODEL_CONTEXT_WINDOWS) {
+    if (model_.includes(m)) {
+      return window;
+    }
+  }
+  return model_.includes("claude") ? 2e5 : 128e3;
+}
+function getContextWindow(p) {
+  if (p.context_window && p.context_window > 0) {
+    return p.context_window;
+  }
+  return lookupModelContextWindow(p.model);
+}
+var fetchedWindowCache = /* @__PURE__ */ new Map();
+async function getContextWindowAsync(p, fetcher) {
+  if (p.context_window && p.context_window > 0) {
+    return p.context_window;
+  }
+  if (p.protocol === "anthropic") {
+    const key = `${p.name}-${p.model}`;
+    let fetched = fetchedWindowCache.get(key);
+    if (fetched === void 0) {
+      try {
+        const fn = fetcher ?? (await import("./anthropic-7YEN2QTU.js")).fetchModelContextWindow;
+        fetched = await fn(p);
+      } catch (err) {
+        log.error({ err }, "config operation failed");
+        fetched = 0;
+      }
+      fetchedWindowCache.set(key, fetched);
+    }
+    if (fetched && fetched > 0) {
+      return fetched;
+    }
+  }
+  return lookupModelContextWindow(p.model);
+}
+function _resetContextWindowCache() {
+  fetchedWindowCache.clear();
+}
+function getMaxOutputTokens(p) {
+  if (p.max_output_tokens && p.max_output_tokens > 0) {
+    return p.max_output_tokens;
+  }
+  if (p.thinking) {
+    return 64e3;
+  }
+  return 8192;
+}
+function resolveAPIKey(p) {
+  if (p.api_key) {
+    return p.api_key;
+  }
+  const envVar = isKeyofTypeofEnvKeyMap(p.protocol) ? ENV_KEY_MAP[p.protocol] : "";
+  if (!envVar) {
+    return "";
+  }
+  return process.env[envVar] ?? "";
+}
+var MCPServerConfigSchema = z.object({
+  name: z.string(),
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  url: z.string().optional(),
+  transport: z.string().optional(),
+  headers: z.record(z.string(), z.string()).optional(),
+  env: z.record(z.string(), z.string()).optional()
+});
+var HookConfigSchema = z.object({
+  id: z.string().optional(),
+  event: z.string(),
+  condition: z.string().optional(),
+  action: z.object({
+    type: z.string(),
+    command: z.string().optional(),
+    url: z.string().optional(),
+    method: z.string().optional(),
+    prompt: z.string().optional()
+  }),
+  reject: z.boolean().optional(),
+  once: z.boolean().optional(),
+  async: z.boolean().optional(),
+  on_error: z.string().optional()
+});
+var SandboxYamlConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  auto_allow: z.boolean().optional(),
+  network_enabled: z.boolean().optional()
+});
+var AppConfigSchema = z.looseObject({
+  providers: z.array(ProviderConfigSchema),
+  permission_mode: z.string().optional(),
+  mcp_servers: z.array(MCPServerConfigSchema).default([]),
+  hooks: z.array(HookConfigSchema).default([]),
+  sandbox: SandboxYamlConfigSchema.optional(),
+  enable_coordinator_mode: z.boolean().optional(),
+  /**
+   * Whether to fork when subagent_type is omitted. Enabled by default, so this
+   * field is left as undefined to represent "not specified in config". Using a
+   * concrete boolean would make it impossible to distinguish "not set" from
+   * "explicitly false", and the latter could never be turned back off.
+   */
+  enable_fork: z.boolean().optional()
+});
+function forkEnabled(cfg) {
+  return cfg.enable_fork !== false;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function loadSingleFile(path) {
+  const data = readFileSync(path, "utf-8");
+  const raw = yaml.load(data);
+  if (!isRecord(raw)) {
+    log.error({ path }, "invalid yaml");
+    return { providers: [], mcp_servers: [], hooks: [] };
+  }
+  const parsed = safeParse(AppConfigSchema, raw);
+  if (parsed.success) {
+    const data2 = parsed.data;
+    return {
+      providers: data2.providers,
+      permission_mode: data2.permission_mode,
+      mcp_servers: data2.mcp_servers,
+      hooks: data2.hooks
+    };
+  }
+  log.error({ error: parsed.error }, "config error");
+  let providers = [];
+  let permissionMode;
+  let mcpServers = [];
+  let hooks = [];
+  let sandbox = void 0;
+  let enableCoordinatorMode = false;
+  let enableFork = true;
+  if ("providers" in raw) {
+    const parsed2 = safeParse(z.array(ProviderConfigSchema), raw.providers);
+    if (parsed2.success) {
+      providers = parsed2.data;
+    }
+  }
+  if ("permission_mode" in raw && typeof raw.permission_mode === "string") {
+    permissionMode = raw.permission_mode;
+  }
+  if ("mcp_servers" in raw) {
+    const parsed2 = safeParse(z.array(MCPServerConfigSchema), raw.mcp_servers);
+    if (parsed2.success) {
+      mcpServers = parsed2.data;
+    }
+  }
+  if ("hooks" in raw) {
+    const parsed2 = safeParse(z.array(HookConfigSchema), raw.hooks);
+    if (parsed2.success) {
+      hooks = parsed2.data;
+    }
+  }
+  if ("sandbox" in raw) {
+    const parsed2 = safeParse(SandboxYamlConfigSchema, raw.sandbox);
+    if (parsed2.success) {
+      sandbox = parsed2.data;
+    }
+  }
+  if ("enable_coordinator_mode" in raw) {
+    enableCoordinatorMode = Boolean(raw.enable_coordinator_mode);
+  }
+  if ("enable_fork" in raw) {
+    enableFork = Boolean(raw.enable_fork);
+  }
+  return {
+    providers,
+    permission_mode: permissionMode,
+    mcp_servers: mcpServers,
+    hooks,
+    sandbox,
+    enable_coordinator_mode: enableCoordinatorMode,
+    enable_fork: enableFork
+  };
+}
+function mergeConfig(base, override) {
+  if (override.providers.length > 0) {
+    base.providers = override.providers;
+  }
+  if (override.permission_mode) {
+    base.permission_mode = override.permission_mode;
+  }
+  if (override.mcp_servers.length > 0) {
+    const mcpToIdx = /* @__PURE__ */ new Map();
+    for (let i = 0; i < base.mcp_servers.length; i++) {
+      const mcp = base.mcp_servers[i];
+      mcpToIdx.set(mcp.name, i);
+    }
+    for (const s of override.mcp_servers) {
+      const idx = mcpToIdx.get(s.name);
+      if (idx !== void 0) {
+        base.mcp_servers[idx] = s;
+      } else {
+        base.mcp_servers.push(s);
+        mcpToIdx.set(s.name, base.mcp_servers.length - 1);
+      }
+    }
+  }
+  base.hooks = [...base.hooks, ...override.hooks];
+  if (override.sandbox) {
+    base.sandbox = { ...base.sandbox, ...override.sandbox };
+  }
+  if (override.enable_coordinator_mode) {
+    base.enable_coordinator_mode = true;
+  }
+  if (override.enable_fork !== void 0) {
+    base.enable_fork = override.enable_fork;
+  }
+  return base;
+}
+function validateProviders(config) {
+  if (config.providers.length === 0) {
+    throw new ConfigError("At least one provider MUST be configured.");
+  }
+  const requiredFields = ["name", "protocol", "base_url", "model"];
+  for (let i = 0; i < config.providers.length; i++) {
+    const p = config.providers[i];
+    const values = {
+      name: p.name,
+      protocol: p.protocol,
+      base_url: p.base_url,
+      model: p.model
+    };
+    const missing = requiredFields.filter((field) => !(field in values));
+    if (missing.length > 0) {
+      throw new ConfigError(`Provider #${String(i + 1)}: missing fields: ${missing.join(", ")}`);
+    }
+    if (!VALID_PROTOCOLS.has(p.protocol)) {
+      throw new ConfigError(
+        `Provider #${String(i + 1)}: invalid protocol '${p.protocol}', MUST be one of: ${Array.from(VALID_PROTOCOLS).join(", ")}`
+      );
+    }
+  }
+}
+function loadConfig(path) {
+  if (path) {
+    const config = loadSingleFile(path);
+    validateProviders(config);
+    return config;
+  }
+  const wd = process.cwd();
+  const home = homedir();
+  const candidates = [
+    join(home, ".swifty", "config.yaml"),
+    join(wd, ".swifty", "config.yaml"),
+    join(wd, ".swifty", "config.local.yaml")
+  ];
+  let merged = null;
+  for (const candidate of candidates) {
+    if (!existsSync(candidate)) {
+      continue;
+    }
+    const layer = loadSingleFile(candidate);
+    if (!merged) {
+      merged = layer;
+    } else {
+      merged = mergeConfig(merged, layer);
+    }
+  }
+  if (!merged) {
+    throw new ConfigError(
+      "No config file found, expected .swifty/config.y(a)ml under project or $HOME/.swifty/config.y(a)ml."
+    );
+  }
+  validateProviders(merged);
+  return merged;
+}
+
+export {
+  ConfigError,
+  ProviderConfigSchema,
+  lookupModelContextWindow,
+  getContextWindow,
+  getContextWindowAsync,
+  _resetContextWindowCache,
+  getMaxOutputTokens,
+  resolveAPIKey,
+  HookConfigSchema,
+  forkEnabled,
+  mergeConfig,
+  loadConfig
+};

package/dist/lib/chunk-EY7HE52Q.js

@@ -0,0 +1,384 @@
+// src/logger/logger.ts
+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(), ".swifty", "logs");
+  return join(dir, `${opts.sessionId}.jsonl`);
+}
+function ensureSwiftyGitignore(logPath) {
+  let dir = dirname(logPath);
+  while (basename(dir) !== ".swifty") {
+    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 });
+  ensureSwiftyGitignore(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, ".swifty", "logs"));
+  const teamsDir = join(homedir(), ".swifty", "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/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 quickSort(arr, compare) {
+  if (arr.length <= 1) {
+    return [...arr];
+  }
+  const pivotIndex = Math.floor(arr.length / 2);
+  const pivot = arr[pivotIndex];
+  if (pivot === void 0) {
+    return [...arr];
+  }
+  const left = [];
+  const right = [];
+  const equal = [];
+  for (const item of arr) {
+    const result = compare(item, pivot);
+    if (result < 0) {
+      left.push(item);
+    } else if (result > 0) {
+      right.push(item);
+    } else {
+      equal.push(item);
+    }
+  }
+  return [...quickSort(left, compare), ...equal, ...quickSort(right, compare)];
+}
+
+export {
+  sanitizeNameSegment,
+  initLogger,
+  closeLogger,
+  logger,
+  createChildLogger,
+  contentToText,
+  isRecord,
+  asRecord,
+  asString,
+  asErrorString,
+  isObject,
+  toTry,
+  safeJSONParse,
+  asError,
+  intArg,
+  strList,
+  strArg,
+  boolArg,
+  quickSort
+};