@swifty.js/swifty 0.0.27 → 0.0.29

package/dist/lib/chunk-3LU4APFB.js

@@ -1,339 +0,0 @@
-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-RYPJDHQM.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-OO2CLOEE.js

@@ -1,88 +0,0 @@
-// 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/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 resolved = /* @__PURE__ */ new Set();
-  const issued = /* @__PURE__ */ new Set();
-  for (const m of messages) {
-    for (const tr of m.toolResults ?? []) {
-      resolved.add(tr.toolUseId);
-    }
-    for (const tu of m.toolUses ?? []) {
-      issued.add(tu.toolUseId);
-    }
-  }
-  const out = [];
-  for (const m of messages) {
-    let current = m;
-    if ((m.toolResults?.length ?? 0) > 0) {
-      const kept = (m.toolResults ?? []).filter((tr) => issued.has(tr.toolUseId));
-      if (kept.length === 0 && !m.content && !(m.toolUses?.length ?? 0)) {
-        continue;
-      }
-      current = { ...m, toolResults: kept };
-    }
-    out.push(current);
-    const missing = [];
-    for (const tu of m.toolUses ?? []) {
-      if (resolved.has(tu.toolUseId)) {
-        continue;
-      }
-      missing.push({
-        toolUseId: tu.toolUseId,
-        content: INTERRUPTED_TOOL_RESULT,
-        isError: true
-      });
-      resolved.add(tu.toolUseId);
-    }
-    if (missing.length > 0) {
-      out.push({ role: "user", content: "", toolResults: missing });
-    }
-  }
-  return out;
-}
-
-export {
-  LLMError,
-  AuthenticationError,
-  RateLimitError,
-  NetworkError,
-  ContextTooLongError,
-  INTERRUPTED_TOOL_RESULT,
-  REJECTED_TOOL_RESULT,
-  ensureToolPairing
-};