@swifty.js/swifty 0.0.27 → 0.0.29

package/dist/lib/chunk-Z4CYHTII.js

@@ -0,0 +1,392 @@
+import {
+  createChildLogger
+} from "./chunk-EY7HE52Q.js";
+
+// src/llm/errors.ts
+var LLMError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LLMError";
+  }
+};
+var AuthenticationError = class extends LLMError {
+  constructor(message) {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends LLMError {
+  retryAfter;
+  constructor(message, retryAfter) {
+    super(message);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var NetworkError = class extends LLMError {
+  constructor(message) {
+    super(message);
+    this.name = "NetworkError";
+  }
+};
+var ContextTooLongError = class extends LLMError {
+  constructor(message) {
+    super(message);
+    this.name = "ContextTooLongError";
+  }
+};
+
+// 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";
+  }
+};
+function globalConfigPath() {
+  return join(homedir(), ".swifty", "config.yaml");
+}
+var THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+var ThinkingConfigSchema = z.union([z.boolean(), z.enum(THINKING_LEVELS)]);
+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: ThinkingConfigSchema.optional(),
+  context_window: z.coerce.number().optional(),
+  /**
+   * The model's output ceiling (PI's `model.maxTokens`). Clamped to the
+   * context window; reasoning shares this ceiling instead of raising it.
+   */
+  max_output_tokens: z.coerce.number().optional()
+});
+var DEFAULT_THINKING_LEVEL = "high";
+var DEFAULT_CONTEXT_WINDOW = 1e6;
+var DEFAULT_MAX_OUTPUT_TOKENS = 128e3;
+var THINKING_BUDGETS = {
+  minimal: 1024,
+  low: 2048,
+  medium: 8192,
+  high: 16384,
+  xhigh: 32768,
+  max: 65536
+};
+function isValidThinkingLevel(value) {
+  return THINKING_LEVELS.includes(value);
+}
+function defaultThinkingLevelFor(protocol) {
+  return protocol === "anthropic" ? DEFAULT_THINKING_LEVEL : "off";
+}
+function getThinkingLevel(provider) {
+  const thinking = provider.thinking;
+  if (thinking === void 0) {
+    return defaultThinkingLevelFor(provider.protocol);
+  }
+  if (typeof thinking === "boolean") {
+    return thinking ? defaultThinkingLevelFor(provider.protocol) : "off";
+  }
+  return thinking;
+}
+function thinkingBudgetForLevel(level) {
+  return level === "off" ? 0 : THINKING_BUDGETS[level];
+}
+function toReasoningEffort(level) {
+  return level === "off" ? "none" : level;
+}
+function withProviderDefaults(provider) {
+  return {
+    ...provider,
+    thinking: getThinkingLevel(provider),
+    context_window: getContextWindow(provider),
+    max_output_tokens: getMaxOutputTokens(provider)
+  };
+}
+function getContextWindow(provider) {
+  return Number.isSafeInteger(provider.context_window) && (provider.context_window ?? 0) > 0 ? provider.context_window ?? DEFAULT_CONTEXT_WINDOW : DEFAULT_CONTEXT_WINDOW;
+}
+function getMaxOutputTokens(provider) {
+  const configured = provider.max_output_tokens;
+  const maxOutput = Number.isSafeInteger(configured) && (configured ?? 0) > 0 ? configured ?? DEFAULT_MAX_OUTPUT_TOKENS : DEFAULT_MAX_OUTPUT_TOKENS;
+  return Math.min(maxOutput, getContextWindow(provider));
+}
+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 {
+      ...data2,
+      providers: data2.providers.map(withProviderDefaults)
+    };
+  }
+  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.map(withProviderDefaults);
+    }
+  }
+  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 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) => !values[field].trim());
+    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, options = {}) {
+  if (path) {
+    const config2 = loadSingleFile(path);
+    if (!options.allowEmptyProviders || config2.providers.length > 0) {
+      validateProviders(config2);
+    }
+    return config2;
+  }
+  const candidate = globalConfigPath();
+  if (!existsSync(candidate)) {
+    if (options.allowEmptyProviders) {
+      return { providers: [], mcp_servers: [], hooks: [] };
+    }
+    const legacy = [
+      join(process.cwd(), ".swifty/config.yaml"),
+      join(process.cwd(), ".swifty/config.local.yaml")
+    ].filter((legacyPath) => existsSync(legacyPath)).join(", ");
+    throw new ConfigError(
+      `No config file found, expected ${candidate}.` + (legacy ? ` Found project config at ${legacy}; move it to ${candidate}.` : "")
+    );
+  }
+  const config = loadSingleFile(candidate);
+  if (!options.allowEmptyProviders || config.providers.length > 0) {
+    validateProviders(config);
+  }
+  return config;
+}
+
+// src/conversation/pairing.ts
+var INTERRUPTED_TOOL_RESULT = "Tool execution was interrupted. The tool may or may not have completed; verify before relying on its effects.";
+var REJECTED_TOOL_RESULT = "The user rejected this tool use. Nothing was changed (for file edits, the new content was NOT written).";
+function ensureToolPairing(messages) {
+  const out = [];
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i];
+    if (m.role === "assistant" && m.toolUses?.length) {
+      out.push(m);
+      const pending = new Set(m.toolUses.map((tu) => tu.toolUseId));
+      const results = [];
+      const resultMessages = [];
+      while (i + 1 < messages.length) {
+        const next = messages[i + 1];
+        if (next.role !== "user" || !next.toolResults?.length || next.toolUses?.length) {
+          break;
+        }
+        i++;
+        resultMessages.push(next);
+        for (const tr of next.toolResults) {
+          if (pending.delete(tr.toolUseId)) {
+            results.push(tr);
+          }
+        }
+      }
+      for (const toolUseId of pending) {
+        results.push({ toolUseId, content: INTERRUPTED_TOOL_RESULT, isError: true });
+      }
+      out.push({
+        ...resultMessages[0] ?? { role: "user", content: "" },
+        toolResults: results
+      });
+      for (const remaining of resultMessages.slice(1)) {
+        if (remaining.content.length > 0 || remaining.thinkingBlocks?.length) {
+          out.push({ ...remaining, toolResults: [] });
+        }
+      }
+      continue;
+    }
+    if ((m.toolResults?.length ?? 0) > 0) {
+      if (m.content.length === 0 && !m.toolUses?.length && !m.thinkingBlocks?.length) {
+        continue;
+      }
+      out.push({ ...m, toolResults: [] });
+    } else {
+      out.push(m);
+    }
+  }
+  return out;
+}
+
+export {
+  LLMError,
+  AuthenticationError,
+  RateLimitError,
+  NetworkError,
+  ContextTooLongError,
+  ConfigError,
+  globalConfigPath,
+  THINKING_LEVELS,
+  ProviderConfigSchema,
+  DEFAULT_THINKING_LEVEL,
+  DEFAULT_CONTEXT_WINDOW,
+  DEFAULT_MAX_OUTPUT_TOKENS,
+  THINKING_BUDGETS,
+  isValidThinkingLevel,
+  defaultThinkingLevelFor,
+  getThinkingLevel,
+  thinkingBudgetForLevel,
+  toReasoningEffort,
+  withProviderDefaults,
+  getContextWindow,
+  getMaxOutputTokens,
+  resolveAPIKey,
+  HookConfigSchema,
+  forkEnabled,
+  loadConfig,
+  INTERRUPTED_TOOL_RESULT,
+  REJECTED_TOOL_RESULT,
+  ensureToolPairing
+};