@swifty.js/swifty 0.0.21 → 0.0.22

package/dist/lib/chunk-EJLGB2EJ.js

@@ -0,0 +1,377 @@
+// 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" });
+var DANGEROUSLY_JSON = "dangerouslyJson";
+function contentToText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  const parts = [];
+  for (const block of content) {
+    if (block.type === "text" && typeof block.text === "string") {
+      const b = block;
+      parts.push(b.text);
+    } else if (block.type === "image" && typeof block.source === "object") {
+      const b = block;
+      const mediaType = b.source.type === "base64" ? b.source.media_type : "image";
+      parts.push(`[Image: ${mediaType}]`);
+    }
+  }
+  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,
+  DANGEROUSLY_JSON,
+  contentToText,
+  isRecord,
+  asRecord,
+  asString,
+  asErrorString,
+  isObject,
+  toTry,
+  safeJSONParse,
+  asError,
+  intArg,
+  strList,
+  strArg,
+  boolArg,
+  quickSort
+};

package/dist/lib/chunk-GHF2PSEW.js

@@ -0,0 +1,8 @@
+// src/tools/tool-names.ts
+var TOOL_SEARCH_TOOL_NAME = "ToolSearch";
+var MCP_CALL_TOOL_NAME = "McpCall";
+
+export {
+  TOOL_SEARCH_TOOL_NAME,
+  MCP_CALL_TOOL_NAME
+};

package/dist/lib/chunk-GNBXECZN.js

@@ -0,0 +1,243 @@
+import {
+  asErrorString,
+  asRecord,
+  createChildLogger,
+  strArg
+} from "./chunk-EJLGB2EJ.js";
+import {
+  MCP_CALL_TOOL_NAME
+} from "./chunk-GHF2PSEW.js";
+
+// src/mcp/tool-wrapper.ts
+var log = createChildLogger({ module: "mcp" });
+var MCP_TOOL_PREFIX = "mcp__";
+var MCP_NAME_SEP = "__";
+function sanitizeSegment(s) {
+  return s.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function mcpToolNamePrefix(serverName) {
+  return MCP_TOOL_PREFIX + sanitizeSegment(serverName) + MCP_NAME_SEP;
+}
+function buildMcpToolName(serverName, toolName) {
+  return mcpToolNamePrefix(serverName) + sanitizeSegment(toolName);
+}
+var MCPToolWrapper = class {
+  name;
+  description;
+  category = "command";
+  // MCP tools are lazily loaded by default to avoid cramming all schemas into the prompt
+  deferred = true;
+  mcpServerName;
+  client;
+  originalName;
+  inputSchema;
+  constructor(client, serverName, tool) {
+    this.name = buildMcpToolName(serverName, tool.name);
+    this.description = tool.description;
+    this.originalName = tool.name;
+    this.client = client;
+    this.inputSchema = tool.inputSchema;
+    this.mcpServerName = serverName;
+  }
+  /** Original JSON schema. McpCall's argument coercion walks it layer by layer. */
+  mcpInputSchema() {
+    return this.inputSchema ?? {};
+  }
+  /** In eager mode the defer flag is cleared so MCP tools go straight into tools[]. */
+  setDeferLoading(on) {
+    this.deferred = on;
+  }
+  schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      input_schema: this.inputSchema
+    };
+  }
+  async execute(_ctx, args) {
+    try {
+      const { output, isError } = await this.client.callTool(this.originalName, args);
+      return { output, isError };
+    } catch (err) {
+      log.error({ err }, "mcp operation failed");
+      return {
+        output: `MCP tool error: ${asErrorString(err)}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/tools/mcp-call.ts
+function coerceScalar(value, want) {
+  if (want === "string" && typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  if ((want === "integer" || want === "number") && typeof value === "string") {
+    const text = value.trim();
+    if (text === "") {
+      return value;
+    }
+    const shape = want === "integer" ? /^[+-]?\d+$/ : /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/;
+    if (!shape.test(text)) {
+      return value;
+    }
+    const parsed = want === "integer" ? Number.parseInt(text, 10) : Number.parseFloat(text);
+    return Number.isNaN(parsed) ? value : parsed;
+  }
+  if (want === "boolean" && typeof value === "string") {
+    const low = value.trim().toLowerCase();
+    if (low === "true") {
+      return true;
+    }
+    if (low === "false") {
+      return false;
+    }
+  }
+  return value;
+}
+function coerceBySchema(value, schema) {
+  if (typeof schema !== "object" || schema === null) {
+    return value;
+  }
+  const schemaObj = asRecord(schema);
+  const want = strArg(schemaObj, "type", "");
+  if (want === "object" && typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const props = asRecord(schemaObj.properties ?? {});
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      out[key] = key in props ? coerceBySchema(item, props[key]) : item;
+    }
+    return out;
+  }
+  if (want === "array") {
+    const itemSchema = schemaObj.items ?? {};
+    let working = value;
+    if (typeof working === "object" && working !== null && !Array.isArray(working)) {
+      const entries = Object.values(working);
+      if (entries.length === 1 && Array.isArray(entries[0])) {
+        working = entries[0];
+      }
+    } else if (typeof working === "string") {
+      working = working.split(",").map((p) => p.trim()).filter((p) => p !== "");
+    }
+    if (Array.isArray(working)) {
+      return working.map((item) => coerceBySchema(item, itemSchema));
+    }
+    return working;
+  }
+  if (want !== "") {
+    return coerceScalar(value, want);
+  }
+  return value;
+}
+function mcpCallPermissionContent(server, tool) {
+  if (tool.startsWith(MCP_TOOL_PREFIX)) {
+    const rest = tool.slice(MCP_TOOL_PREFIX.length);
+    const idx = rest.indexOf(MCP_NAME_SEP);
+    if (idx >= 0) {
+      return sanitizeSegment(rest.slice(0, idx)) + MCP_NAME_SEP + sanitizeSegment(rest.slice(idx + MCP_NAME_SEP.length));
+    }
+  }
+  return sanitizeSegment(server) + MCP_NAME_SEP + sanitizeSegment(tool);
+}
+function isMcpToolLike(tool) {
+  return "mcpInputSchema" in tool && typeof tool.mcpInputSchema === "function";
+}
+var McpCallTool = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  registry;
+  name = MCP_CALL_TOOL_NAME;
+  description = "Invoke a tool on a connected MCP server. Call ToolSearch first to load the tool's schema, then pass its arguments here exactly as that schema requires, using the same JSON types.";
+  category = "command";
+  // This tool must stay in tools[] itself, otherwise the model has no entry point
+  deferred = false;
+  schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      input_schema: {
+        type: "object",
+        properties: {
+          server: {
+            type: "string",
+            description: "MCP server name, e.g. 'linear'."
+          },
+          tool: {
+            type: "string",
+            description: "Full tool name as returned by ToolSearch, e.g. 'mcp__linear__create_issue'."
+          },
+          arguments: {
+            type: "object",
+            description: "The target tool's arguments. Must match that tool's input_schema exactly, including JSON types: bare numbers for integer fields, bare true/false for boolean fields, quoted strings for string fields, and plain JSON arrays for array fields."
+          }
+        },
+        required: ["server", "tool", "arguments"]
+      }
+    };
+  }
+  /**
+   * Try in order: full name / server+short name / unique short-name suffix match.
+   *
+   * The model very often passes only the short name (roughly three in ten calls in
+   * practice), so this must be tolerant — otherwise it needlessly costs a retry
+   * round.
+   */
+  resolve(server, tool) {
+    const direct = this.registry.get(tool) ?? this.registry.get(buildMcpToolName(server, tool));
+    if (direct) {
+      return direct;
+    }
+    const suffix = MCP_NAME_SEP + sanitizeSegment(tool);
+    const matches = this.registry.listTools().filter((t) => t.name.startsWith(MCP_TOOL_PREFIX) && t.name.endsWith(suffix));
+    return matches.length === 1 ? matches[0] : void 0;
+  }
+  availableNames() {
+    return this.registry.listTools().filter((t) => t.name.startsWith(MCP_TOOL_PREFIX)).map((t) => t.name).sort();
+  }
+  async execute(ctx, args) {
+    const server = strArg(args, "server", "");
+    const tool = strArg(args, "tool", "");
+    if (tool === "") {
+      return { output: "McpCall requires a 'tool' name", isError: true };
+    }
+    const target = this.resolve(server, tool);
+    if (!target) {
+      const names = this.availableNames();
+      const hint = names.length > 0 ? names.join(", ") : "(none connected)";
+      return {
+        output: `Unknown MCP tool '${tool}' on server '${server}'. Available tools: ${hint}`,
+        isError: true
+      };
+    }
+    let inner = {};
+    if (typeof args.arguments === "object" && args.arguments !== null && !Array.isArray(args.arguments)) {
+      inner = asRecord(args.arguments);
+    }
+    if (isMcpToolLike(target)) {
+      const schema = target.mcpInputSchema();
+      if (Object.keys(schema).length > 0) {
+        const fixed = coerceBySchema(inner, schema);
+        if (typeof fixed === "object" && fixed !== null && !Array.isArray(fixed)) {
+          inner = asRecord(fixed);
+        }
+      }
+    }
+    return target.execute(ctx, inner);
+  }
+};
+
+export {
+  MCP_TOOL_PREFIX,
+  MCP_NAME_SEP,
+  sanitizeSegment,
+  mcpToolNamePrefix,
+  buildMcpToolName,
+  MCPToolWrapper,
+  coerceBySchema,
+  mcpCallPermissionContent,
+  isMcpToolLike,
+  McpCallTool
+};