@swifty.js/swifty 0.0.29 → 0.0.30

package/dist/lib/{chunk-Z4CYHTII.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" });
@@ -63,8 +63,18 @@ 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({
+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"]
@@ -73,7 +83,12 @@ var ProviderConfigSchema = z.object({
   base_url: z.string(),
   model: z.string(),
   api_key: z.string().optional(),
-  thinking: ThinkingConfigSchema.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
@@ -92,27 +107,69 @@ var THINKING_BUDGETS = {
   xhigh: 32768,
   max: 65536
 };
+var MIN_THINKING_BUDGET_TOKENS = 1024;
+var MIN_THINKING_ANSWER_TOKENS = 1024;
 function isValidThinkingLevel(value) {
-  return THINKING_LEVELS.includes(value);
-}
-function defaultThinkingLevelFor(protocol) {
-  return protocol === "anthropic" ? DEFAULT_THINKING_LEVEL : "off";
+  return THINKING_LEVELS.some((level) => level === value);
 }
 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;
+  return clampThinkingLevel(provider, provider.thinking ?? DEFAULT_THINKING_LEVEL);
 }
 function thinkingBudgetForLevel(level) {
   return level === "off" ? 0 : THINKING_BUDGETS[level];
 }
-function toReasoningEffort(level) {
-  return level === "off" ? "none" : 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 {
@@ -218,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") {
@@ -294,13 +355,7 @@ function loadConfig(path, options = {}) {
     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}.` : "")
-    );
+    throw new ConfigError(`No config file found, expected ${candidate}.`);
   }
   const config = loadSingleFile(candidate);
   if (!options.allowEmptyProviders || config.providers.length > 0) {
@@ -374,11 +429,15 @@ export {
   DEFAULT_CONTEXT_WINDOW,
   DEFAULT_MAX_OUTPUT_TOKENS,
   THINKING_BUDGETS,
+  MIN_THINKING_BUDGET_TOKENS,
+  MIN_THINKING_ANSWER_TOKENS,
   isValidThinkingLevel,
-  defaultThinkingLevelFor,
   getThinkingLevel,
   thinkingBudgetForLevel,
   toReasoningEffort,
+  toAnthropicThinkingEffort,
+  getSupportedThinkingLevels,
+  clampThinkingLevel,
   withProviderDefaults,
   getContextWindow,
   getMaxOutputTokens,

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"