@swifty.js/swifty 0.0.28 → 0.0.30

package/dist/lib/{chunk-FBSPZQGC.js → chunk-OQIQOU5S.js}

@@ -40,7 +40,7 @@ var ContextTooLongError = class extends LLMError {
 import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-import { safeParse } from "@modelcontextprotocol/sdk/server/zod-compat.js";
+import { getParseErrorMessage, safeParse } from "@modelcontextprotocol/sdk/server/zod-compat.js";
 import yaml from "js-yaml";
 import { z } from "zod";
 var log = createChildLogger({ module: "config" });
@@ -59,7 +59,22 @@ var ConfigError = class extends Error {
     this.name = "ConfigError";
   }
 };
-var ProviderConfigSchema = z.object({
+function globalConfigPath() {
+  return join(homedir(), ".swifty", "config.yaml");
+}
+var THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+var ReasoningEffortSchema = z.enum(["none", "minimal", "low", "medium", "high", "xhigh", "max"]);
+var AnthropicEffortSchema = z.enum(["low", "medium", "high", "xhigh", "max"]);
+var ThinkingLevelMapSchema = z.strictObject({
+  off: z.literal("none").nullable().optional(),
+  minimal: ReasoningEffortSchema.nullable().optional(),
+  low: ReasoningEffortSchema.nullable().optional(),
+  medium: ReasoningEffortSchema.nullable().optional(),
+  high: ReasoningEffortSchema.nullable().optional(),
+  xhigh: ReasoningEffortSchema.nullable().optional(),
+  max: ReasoningEffortSchema.nullable().optional()
+});
+var ProviderConfigSchema = z.looseObject({
   name: z.string(),
   /**
    * enum: ["anthropic", "openai", "openai-compat"]
@@ -68,17 +83,98 @@ var ProviderConfigSchema = z.object({
   base_url: z.string(),
   model: z.string(),
   api_key: z.string().optional(),
-  thinking: z.boolean().optional(),
+  thinking: z.enum(THINKING_LEVELS).optional(),
+  /** Explicit capability metadata, never inferred from model names. */
+  reasoning: z.boolean().optional(),
+  thinking_level_map: ThinkingLevelMapSchema.optional(),
+  /** Only Anthropic uses this mode; existing configurations use budgets. */
+  thinking_mode: z.enum(["budget", "adaptive"]).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_PROVIDER_THINKING = true;
+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
+};
+var MIN_THINKING_BUDGET_TOKENS = 1024;
+var MIN_THINKING_ANSWER_TOKENS = 1024;
+function isValidThinkingLevel(value) {
+  return THINKING_LEVELS.some((level) => level === value);
+}
+function getThinkingLevel(provider) {
+  return clampThinkingLevel(provider, provider.thinking ?? DEFAULT_THINKING_LEVEL);
+}
+function thinkingBudgetForLevel(level) {
+  return level === "off" ? 0 : THINKING_BUDGETS[level];
+}
+function toReasoningEffort(level, provider) {
+  if (provider?.reasoning === false) {
+    return null;
+  }
+  if (level === "off") {
+    return "none";
+  }
+  const mapped = provider?.thinking_level_map?.[level];
+  if (mapped !== void 0) {
+    return mapped;
+  }
+  if (provider?.protocol === "anthropic" && provider.thinking_mode === "adaptive") {
+    if (level === "minimal") {
+      return "low";
+    }
+    if (level === "xhigh") {
+      return "high";
+    }
+  }
+  return level;
+}
+function toAnthropicThinkingEffort(level, provider) {
+  const parsed = AnthropicEffortSchema.safeParse(toReasoningEffort(level, provider));
+  return parsed.success ? parsed.data : null;
+}
+function getSupportedThinkingLevels(provider) {
+  if (provider.reasoning === false || provider.protocol === "anthropic" && provider.thinking_mode !== "adaptive" && getMaxOutputTokens(provider) < MIN_THINKING_BUDGET_TOKENS + MIN_THINKING_ANSWER_TOKENS) {
+    return ["off"];
+  }
+  return THINKING_LEVELS.filter((level) => {
+    if (level === "off") {
+      return true;
+    }
+    if (provider.protocol === "anthropic" && provider.thinking_mode === "adaptive") {
+      return toAnthropicThinkingEffort(level, provider) !== null;
+    }
+    const effort = toReasoningEffort(level, provider);
+    return effort !== null && effort !== "none";
+  });
+}
+function clampThinkingLevel(provider, level) {
+  const supported = getSupportedThinkingLevels(provider);
+  let effective = "off";
+  for (const candidate of THINKING_LEVELS) {
+    if (supported.includes(candidate)) {
+      effective = candidate;
+    }
+    if (candidate === level) {
+      break;
+    }
+  }
+  return effective;
+}
 function withProviderDefaults(provider) {
   return {
     ...provider,
-    thinking: provider.thinking ?? DEFAULT_PROVIDER_THINKING,
+    thinking: getThinkingLevel(provider),
     context_window: getContextWindow(provider),
     max_output_tokens: getMaxOutputTokens(provider)
   };
@@ -87,7 +183,9 @@ 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) {
-  return Number.isSafeInteger(provider.max_output_tokens) && (provider.max_output_tokens ?? 0) > 0 ? provider.max_output_tokens ?? DEFAULT_MAX_OUTPUT_TOKENS : DEFAULT_MAX_OUTPUT_TOKENS;
+  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) {
@@ -177,6 +275,10 @@ function loadSingleFile(path) {
     const parsed2 = safeParse(z.array(ProviderConfigSchema), raw.providers);
     if (parsed2.success) {
       providers = parsed2.data.map(withProviderDefaults);
+    } else {
+      throw new ConfigError(
+        `Invalid provider configuration in ${path}: ${getParseErrorMessage(parsed2.error)}`
+      );
     }
   }
   if ("permission_mode" in raw && typeof raw.permission_mode === "string") {
@@ -216,41 +318,6 @@ function loadSingleFile(path) {
     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.");
@@ -277,43 +344,24 @@ function validateProviders(config) {
 }
 function loadConfig(path, options = {}) {
   if (path) {
-    const config = loadSingleFile(path);
-    if (!options.allowEmptyProviders || config.providers.length > 0) {
-      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);
+    const config2 = loadSingleFile(path);
+    if (!options.allowEmptyProviders || config2.providers.length > 0) {
+      validateProviders(config2);
     }
+    return config2;
   }
-  if (!merged) {
+  const candidate = globalConfigPath();
+  if (!existsSync(candidate)) {
     if (options.allowEmptyProviders) {
       return { providers: [], mcp_servers: [], hooks: [] };
     }
-    throw new ConfigError(
-      "No config file found, expected .swifty/config.y(a)ml under project or $HOME/.swifty/config.y(a)ml."
-    );
+    throw new ConfigError(`No config file found, expected ${candidate}.`);
   }
-  if (!options.allowEmptyProviders || merged.providers.length > 0) {
-    validateProviders(merged);
+  const config = loadSingleFile(candidate);
+  if (!options.allowEmptyProviders || config.providers.length > 0) {
+    validateProviders(config);
   }
-  return merged;
+  return config;
 }
 
 // src/conversation/pairing.ts
@@ -374,17 +422,28 @@ export {
   NetworkError,
   ContextTooLongError,
   ConfigError,
+  globalConfigPath,
+  THINKING_LEVELS,
   ProviderConfigSchema,
-  DEFAULT_PROVIDER_THINKING,
+  DEFAULT_THINKING_LEVEL,
   DEFAULT_CONTEXT_WINDOW,
   DEFAULT_MAX_OUTPUT_TOKENS,
+  THINKING_BUDGETS,
+  MIN_THINKING_BUDGET_TOKENS,
+  MIN_THINKING_ANSWER_TOKENS,
+  isValidThinkingLevel,
+  getThinkingLevel,
+  thinkingBudgetForLevel,
+  toReasoningEffort,
+  toAnthropicThinkingEffort,
+  getSupportedThinkingLevels,
+  clampThinkingLevel,
   withProviderDefaults,
   getContextWindow,
   getMaxOutputTokens,
   resolveAPIKey,
   HookConfigSchema,
   forkEnabled,
-  mergeConfig,
   loadConfig,
   INTERRUPTED_TOOL_RESULT,
   REJECTED_TOOL_RESULT,

package/dist/lib/{chunk-IB5IQK2S.js → chunk-PIL7M52F.js}

@@ -101,8 +101,7 @@ function isToolResultContentBlock(value) {
   return normalizeToolResultContentBlock(value) !== null;
 }
 var SKIP_DIRS = /* @__PURE__ */ new Set([
-  ".claude",
-  // Claude Code
+  ".agents",
   ".git",
   // Git
   ".swifty",
@@ -113,20 +112,12 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
   // Python venv
   ".mypy_cache",
   // Python mypy
-  ".tox",
-  // Python tox
   "__pycache__",
   // Python
-  "build",
-  // C++
   "dist",
   // Webpack, Vite
-  "node_modules",
+  "node_modules"
   // Node.js
-  "vendor",
-  // Go
-  "venv"
-  // Python venv
 ]);
 
 export {

package/dist/lib/{chunk-DJ6AILPN.js → chunk-RMB3J46W.js}

@@ -88,11 +88,7 @@ var CONTENT_FIELDS = {
   Grep: "pattern",
   InstallSkill: "source"
 };
-var DEFAULT_DENY_WRITE = [
-  ".swifty/config.yaml",
-  ".swifty/permissions.local.yaml",
-  ".swifty/skills/"
-];
+var DEFAULT_DENY_WRITE = [".swifty/permissions.yaml", ".agents/skills/"];
 function extractContent(toolName, args) {
   if (toolName === MCP_CALL_TOOL_NAME) {
     return mcpCallPermissionContent(strArg(args, "server", ""), strArg(args, "tool", ""));
@@ -218,12 +214,10 @@ function evaluateRules(rules, toolName, content) {
 var RuleEngine = class {
   userPath;
   projectPath;
-  localPath;
   cache = /* @__PURE__ */ new Map();
   constructor(workDir) {
     this.userPath = join2(homedir(), ".swifty", "permissions.yaml");
     this.projectPath = join2(workDir, ".swifty", "permissions.yaml");
-    this.localPath = join2(workDir, ".swifty", "permissions.local.yaml");
   }
   // Read a single rules file; skips disk I/O and parsing on cache hit.
   rulesFor(path) {
@@ -242,12 +236,12 @@ var RuleEngine = class {
     this.cache.set(path, { mtimeNs: st.mtimeNs, size: st.size, rules });
     return rules;
   }
-  // Return the merged snapshot of all three rules files. Reuses the previous
+  // Return the merged snapshot of both rules files. Reuses the previous
   // parse result when files are unchanged; re-reads only on change, so edits
   // take effect on the next evaluation without redundant parsing. One snapshot
   // is taken per tool call and shared across sub-command checks.
   snapshot() {
-    return [this.userPath, this.projectPath, this.localPath].flatMap((p) => this.rulesFor(p));
+    return [this.userPath, this.projectPath].flatMap((p) => this.rulesFor(p));
   }
   // Take a snapshot then adjudicate: reuses the previous parse result when
   // files are unchanged; a freshly written "allow always" rule takes effect
@@ -257,11 +251,11 @@ var RuleEngine = class {
   evaluate(toolName, content) {
     return evaluateRules(this.snapshot(), toolName, content);
   }
-  // Persists a rule to the project-local YAML file in the `Tool(pattern)`
+  // Persists a rule to the project-level YAML file in the `Tool(pattern)`
   // format so "allow always" survives a restart.
-  appendLocalRule(rule) {
-    mkdirSync(dirname2(this.localPath), { recursive: true });
-    const rules = loadRulesFile(this.localPath);
+  appendProjectRule(rule) {
+    mkdirSync(dirname2(this.projectPath), { recursive: true });
+    const rules = loadRulesFile(this.projectPath);
     const exists = rules.some(
       (r) => r.tool === rule.tool && r.pattern === rule.pattern && r.effect === rule.effect
     );
@@ -273,7 +267,7 @@ var RuleEngine = class {
       rule: `${r.tool}(${r.pattern})`,
       effect: r.effect
     }));
-    writeFileSync(this.localPath, yaml.dump(entries), "utf-8");
+    writeFileSync(this.projectPath, yaml.dump(entries), "utf-8");
   }
 };
 function detectDangerous(command) {
@@ -334,7 +328,10 @@ var PermissionChecker = class _PermissionChecker {
     const rules = () => snapshot ??= this.ruleEngine.snapshot();
     const explicitEffect = evaluateRules(rules(), toolName, content);
     if (explicitEffect === "deny" || explicitEffect === "ask") {
-      return { effect: explicitEffect, reason: `Permission rule: ${explicitEffect}` };
+      return {
+        effect: explicitEffect,
+        reason: `Permission rule: ${explicitEffect}`
+      };
     }
     if (this.mode === "plan" && (toolName === "WriteFile" || toolName === "EditFile")) {
       const path = strArg(args, "file_path", "");
@@ -432,7 +429,7 @@ var PermissionChecker = class _PermissionChecker {
       const words = content.trim().split(/\s+/).slice(0, 2);
       pattern = words.join(" ") + "*";
     }
-    this.ruleEngine.appendLocalRule({
+    this.ruleEngine.appendProjectRule({
       tool: toolName,
       pattern,
       effect: "allow"