@swifty.js/swifty 0.0.27 → 0.0.29

package/dist/lib/{chunk-XFSN4LMA.js → chunk-3FBS5NB7.js}

@@ -1,15 +1,15 @@
-import {
-  getMaxOutputTokens,
-  resolveAPIKey
-} from "./chunk-3LU4APFB.js";
 import {
   AuthenticationError,
   ContextTooLongError,
   LLMError,
   NetworkError,
   RateLimitError,
-  ensureToolPairing
-} from "./chunk-OO2CLOEE.js";
+  ensureToolPairing,
+  getMaxOutputTokens,
+  getThinkingLevel,
+  resolveAPIKey,
+  toReasoningEffort
+} from "./chunk-Z4CYHTII.js";
 import {
   asRecord,
   asString,
@@ -27,11 +27,12 @@ var OpenAIClient = class {
   model;
   systemPrompt;
   maxOutputTokens;
+  thinkingLevel;
   constructor(config, systemPrompt) {
     const apiKey = resolveAPIKey(config);
     if (!apiKey) {
       throw new AuthenticationError(
-        "OpenAI API key not found, set OPENAI_API_KEY in .swifty/config.y(a)ml, or via OPENAI_API_KEY env variable."
+        "OpenAI API key not found, set OPENAI_API_KEY in ~/.swifty/config.yaml, or via OPENAI_API_KEY env variable."
       );
     }
     this.client = new OpenAI({
@@ -41,6 +42,7 @@ var OpenAIClient = class {
     this.model = config.model;
     this.systemPrompt = systemPrompt;
     this.maxOutputTokens = getMaxOutputTokens(config);
+    this.thinkingLevel = getThinkingLevel(config);
   }
   async *stream(conversation, toolSchemas, abortSignal) {
     const messages = buildOpenAIInput(ensureToolPairing(conversation.getMessages()));
@@ -67,7 +69,10 @@ var OpenAIClient = class {
       input,
       stream: true,
       max_output_tokens: this.maxOutputTokens,
-      ...tools.length > 0 ? { tools } : {}
+      ...tools.length > 0 ? { tools } : {},
+      // PI-equivalent thinking level → Responses API reasoning effort. Omitted
+      // entirely when thinking is off so non-reasoning models are unaffected.
+      ...this.thinkingLevel !== "off" ? { reasoning: { effort: toReasoningEffort(this.thinkingLevel), summary: "auto" } } : {}
     };
     let inputTokens = 0;
     let outputTokens = 0;
@@ -82,6 +87,7 @@ var OpenAIClient = class {
       let jsonAccumulate = "";
       let reasoningId = "";
       let reasoningText = "";
+      let sawTerminalResponse = false;
       for await (const event of stream) {
         if (event.type === "response.output_text.delta") {
           yield {
@@ -139,19 +145,22 @@ var OpenAIClient = class {
             currentToolId = "";
             jsonAccumulate = "";
           }
-        } else if (event.type === "response.completed") {
+        } else if (event.type === "response.completed" || event.type === "response.incomplete") {
+          sawTerminalResponse = true;
           const usage = event.response.usage;
           if (usage) {
             outputTokens = usage.output_tokens;
-            cacheReadInputTokens = usage.input_tokens_details.cached_tokens;
+            cacheReadInputTokens = usage.input_tokens_details?.cached_tokens ?? 0;
             inputTokens = Math.max(0, usage.input_tokens - cacheReadInputTokens);
           }
           let stopReason = "end_turn";
           const resp = event.response;
-          if (resp.status === "incomplete") {
+          if (event.type === "response.incomplete" || resp.status === "incomplete") {
             const details = resp.incomplete_details;
             if (details?.reason === "max_output_tokens") {
               stopReason = "max_tokens";
+            } else {
+              throw new LLMError(`Response incomplete: ${details?.reason ?? "unknown reason"}`);
             }
           }
           yield {
@@ -165,8 +174,18 @@ var OpenAIClient = class {
               // 0
             }
           };
+        } else if (event.type === "response.failed") {
+          const error = event.response.error;
+          const message = `${error?.code ?? "unknown"}: ${error?.message ?? "Response failed"}`;
+          throw containsContextLengthError(message) ? new ContextTooLongError(message) : new LLMError(message);
+        } else if (event.type === "error") {
+          const message = `${event.code ?? "unknown"}: ${event.message}`;
+          throw containsContextLengthError(message) ? new ContextTooLongError(message) : new LLMError(message);
         }
       }
+      if (!sawTerminalResponse) {
+        throw new NetworkError("OpenAI Responses stream ended before a terminal response event");
+      }
     } catch (err) {
       log.error({ err }, "llm operation failed");
       throw classifyOpenAIError(err);
@@ -178,6 +197,12 @@ var OpenAIClient = class {
   setMaxOutputTokens(maxTokens) {
     this.maxOutputTokens = maxTokens;
   }
+  setThinkingLevel(level) {
+    this.thinkingLevel = level;
+  }
+  getThinkingLevel() {
+    return this.thinkingLevel;
+  }
 };
 function imageDataUrl(block) {
   if (!isRecord(block) || block.type !== "image" || !isRecord(block.source)) {
@@ -349,6 +374,9 @@ function buildOpenAIInput(messages) {
           output: toolOutputForResponses(tr)
         });
       }
+      if (m.content.length > 0) {
+        result.push({ role: "user", content: userContentsFor(m.content) });
+      }
     } else if (m.role === "assistant") {
       result.push({
         role: "assistant",
@@ -371,17 +399,19 @@ var OpenAICompatClient = class {
   model;
   systemPrompt;
   maxOutputTokens;
+  thinkingLevel;
   constructor(config, systemPrompt) {
     const apiKey = resolveAPIKey(config);
     if (!apiKey) {
       throw new AuthenticationError(
-        "OpenAI API key not found. Set OPENAI_API_KEY in .swifty/config.y(a)ml, or via OPENAI_API_KEY env variable."
+        "OpenAI API key not found. Set OPENAI_API_KEY in ~/.swifty/config.yaml, or via OPENAI_API_KEY env variable."
       );
     }
     this.client = new OpenAI({ apiKey, baseURL: config.base_url });
     this.model = config.model;
     this.systemPrompt = systemPrompt;
     this.maxOutputTokens = getMaxOutputTokens(config);
+    this.thinkingLevel = getThinkingLevel(config);
   }
   setSystemPrompt(prompt) {
     this.systemPrompt = prompt;
@@ -389,6 +419,12 @@ var OpenAICompatClient = class {
   setMaxOutputTokens(maxTokens) {
     this.maxOutputTokens = maxTokens;
   }
+  setThinkingLevel(level) {
+    this.thinkingLevel = level;
+  }
+  getThinkingLevel() {
+    return this.thinkingLevel;
+  }
   async *stream(conversation, toolSchemas, abortSignal) {
     const messages = [
       {
@@ -414,7 +450,10 @@ var OpenAICompatClient = class {
       stream: true,
       stream_options: { include_usage: true },
       max_tokens: this.maxOutputTokens,
-      ...tools.length > 0 ? { tools } : {}
+      ...tools.length > 0 ? { tools } : {},
+      // PI-equivalent thinking level → Chat Completions reasoning_effort.
+      // Omitted when thinking is off so non-reasoning models are unaffected.
+      ...this.thinkingLevel !== "off" ? { reasoning_effort: toReasoningEffort(this.thinkingLevel) } : {}
     };
     let inputTokens = 0;
     let outputTokens = 0;
@@ -510,6 +549,9 @@ var OpenAICompatClient = class {
           }
         }
       }
+      if (finishReason === null) {
+        throw new NetworkError("Chat Completions stream ended before a finish reason");
+      }
       let stopReason;
       if (finishReason === "length") {
         stopReason = "max_tokens";
@@ -535,6 +577,9 @@ var OpenAICompatClient = class {
   }
 };
 function classifyOpenAIError(err) {
+  if (err instanceof LLMError) {
+    return err;
+  }
   if (err instanceof OpenAI.APIError) {
     if (err.status === 413 /* PromptTooLong */ || err.status === 400 /* BadRequest */ && containsContextLengthError(err.message)) {
       return new ContextTooLongError(`Context Too Long: ${err.message}`);
@@ -543,7 +588,11 @@ function classifyOpenAIError(err) {
       return new AuthenticationError(`Invalid API key: ${err.message}`);
     }
     if (err.status === 429 /* RateLimitError */) {
-      return new RateLimitError(`Rate limit error, please wait.`);
+      const headers = err.headers;
+      return new RateLimitError(
+        "Rate limit error, please wait.",
+        headers instanceof Headers ? headers.get("retry-after") ?? void 0 : void 0
+      );
     }
     return new LLMError(`OpenAI API error (${asString(err.status)}): ${err.message}`);
   }
@@ -558,16 +607,14 @@ function buildChatCompletionMessages(messages) {
       params.push({
         role: "assistant",
         content: assistantText || null,
+        ...reasoning ? { reasoning_content: reasoning } : {},
         tool_calls: m.toolUses.map((tu) => ({
           id: tu.toolUseId,
           type: "function",
           function: {
             name: tu.toolName,
             arguments: JSON.stringify(tu.arguments)
-          },
-          ...reasoning ? {
-            reasoning_content: reasoning
-          } : {}
+          }
         }))
       });
     } else if (m.toolResults && m.toolResults.length > 0) {
@@ -580,6 +627,12 @@ function buildChatCompletionMessages(messages) {
         });
         pendingRichParts.push(...collectRichParts(tr));
       }
+      if (m.content.length > 0) {
+        const content = userPartsFor(m.content);
+        pendingRichParts.push(
+          ...typeof content === "string" ? [{ type: "text", text: content }] : content
+        );
+      }
       if (pendingRichParts.length > 0) {
         params.push({
           role: "user",

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

@@ -1,6 +1,6 @@
 import {
   mcpCallPermissionContent
-} from "./chunk-PZ42NAFA.js";
+} from "./chunk-KG4MJGKQ.js";
 import {
   createChildLogger,
   strArg
@@ -12,9 +12,38 @@ import {
 // src/permissions/checker.ts
 import { readFileSync, writeFileSync, mkdirSync, statSync } from "fs";
 import { homedir, tmpdir } from "os";
-import { join, resolve, dirname } from "path";
+import { join as join2, resolve as resolve2, dirname as dirname2 } from "path";
 import yaml from "js-yaml";
 import z, { parse } from "zod";
+
+// src/utils/paths.ts
+import { realpathSync } from "fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "path";
+function canonicalPath(path) {
+  let current = resolve(path);
+  const missing = [];
+  for (; ; ) {
+    try {
+      return join(realpathSync(current), ...missing);
+    } catch (error) {
+      if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT" && error.code !== "ENOTDIR") {
+        throw error;
+      }
+      const parent = dirname(current);
+      if (parent === current) {
+        return resolve(path);
+      }
+      missing.unshift(basename(current));
+      current = parent;
+    }
+  }
+}
+function isPathWithin(root, path) {
+  const child = relative(root, path);
+  return child === "" || child !== ".." && !child.startsWith(`..${sep}`) && !isAbsolute(child);
+}
+
+// src/permissions/checker.ts
 var log = createChildLogger({ module: "permissions" });
 var DANGEROUS_PATTERNS = [];
 var SAFE_PREFIXES = [
@@ -56,7 +85,8 @@ var CONTENT_FIELDS = {
   WriteFile: "file_path",
   EditFile: "file_path",
   Glob: "pattern",
-  Grep: "pattern"
+  Grep: "pattern",
+  InstallSkill: "source"
 };
 var DEFAULT_DENY_WRITE = [
   ".swifty/config.yaml",
@@ -79,25 +109,26 @@ var PathSandbox = class {
   denyWritePaths;
   projectDir;
   constructor(projectDir) {
-    this.projectDir = resolve(projectDir);
+    this.projectDir = resolve2(projectDir);
     this.allowedRoots = [this.projectDir, tmpdir()];
-    this.denyWritePaths = DEFAULT_DENY_WRITE.map((p) => join(this.projectDir, p));
+    this.denyWritePaths = DEFAULT_DENY_WRITE.map((p) => join2(this.projectDir, p));
   }
   addRoot(root) {
-    this.allowedRoots.push(resolve(root));
+    this.allowedRoots.push(resolve2(root));
   }
   // Add custom deny-write paths
   addDenyWrite(path) {
-    this.denyWritePaths.push(resolve(path));
+    this.denyWritePaths.push(resolve2(path));
   }
   /**
    * Check whether a path is in the deny-write list.
    * denyWrite has the highest priority — even if the path is within an allowed root, writes are still denied.
    */
   checkDenyWrite(filePath) {
-    const absolute = resolve(filePath);
+    const absolute = resolve2(this.projectDir, filePath);
+    const canonical = canonicalPath(absolute);
     for (const denied of this.denyWritePaths) {
-      if (absolute.startsWith(denied)) {
+      if (isPathWithin(denied, absolute) || isPathWithin(canonicalPath(denied), canonical)) {
         return {
           effect: "deny",
           reason: `Path ${filePath} is in deny-write list`
@@ -107,9 +138,9 @@ var PathSandbox = class {
     return null;
   }
   check(filePath) {
-    const absolute = resolve(filePath);
+    const absolute = canonicalPath(resolve2(this.projectDir, filePath));
     for (const root of this.allowedRoots) {
-      if (absolute.startsWith(root)) {
+      if (isPathWithin(canonicalPath(root), absolute)) {
         return null;
       }
     }
@@ -190,9 +221,9 @@ var RuleEngine = class {
   localPath;
   cache = /* @__PURE__ */ new Map();
   constructor(workDir) {
-    this.userPath = join(homedir(), ".swifty", "permissions.yaml");
-    this.projectPath = join(workDir, ".swifty", "permissions.yaml");
-    this.localPath = join(workDir, ".swifty", "permissions.local.yaml");
+    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) {
@@ -229,7 +260,7 @@ var RuleEngine = class {
   // Persists a rule to the project-local YAML file in the `Tool(pattern)`
   // format so "allow always" survives a restart.
   appendLocalRule(rule) {
-    mkdirSync(dirname(this.localPath), { recursive: true });
+    mkdirSync(dirname2(this.localPath), { recursive: true });
     const rules = loadRulesFile(this.localPath);
     const exists = rules.some(
       (r) => r.tool === rule.tool && r.pattern === rule.pattern && r.effect === rule.effect
@@ -255,7 +286,7 @@ function detectDangerous(command) {
 }
 function isSafeCommand(command) {
   const trimmed = command.trim();
-  if (trimmed.includes(">") || trimmed.includes("|") || trimmed.includes(";") || trimmed.includes("&&") || trimmed.includes("$(") || trimmed.includes("`")) {
+  if (trimmed.includes(">") || trimmed.includes("<") || /[\r\n&]/.test(trimmed) || trimmed.includes("|") || trimmed.includes(";") || trimmed.includes("&&") || trimmed.includes("$(") || trimmed.includes("`")) {
     return false;
   }
   return SAFE_PREFIXES.some(
@@ -275,7 +306,14 @@ function modeDecide(mode, category) {
       return category === "read" ? "allow" : "ask";
   }
 }
-var PermissionChecker = class {
+var PermissionChecker = class _PermissionChecker {
+  constructor(workDir, mode = "default") {
+    this.workDir = workDir;
+    this.mode = mode;
+    this.sandbox = new PathSandbox(workDir);
+    this.ruleEngine = new RuleEngine(workDir);
+  }
+  workDir;
   mode;
   planFilePath = "";
   // Sandbox mode: when enabled, command-category tools run through OS sandbox isolation, with optional auto-allow
@@ -283,18 +321,24 @@ var PermissionChecker = class {
   sandboxAutoAllow = false;
   sandbox;
   ruleEngine;
-  constructor(workDir, mode = "default") {
-    this.mode = mode;
-    this.sandbox = new PathSandbox(workDir);
-    this.ruleEngine = new RuleEngine(workDir);
+  forWorkDir(workDir) {
+    const checker = new _PermissionChecker(workDir, this.mode);
+    checker.ruleEngine = this.ruleEngine;
+    checker.sandboxEnabled = this.sandboxEnabled;
+    checker.sandboxAutoAllow = this.sandboxAutoAllow;
+    return checker;
   }
   check(toolName, category, args) {
     const content = extractContent(toolName, args);
     let snapshot = null;
     const rules = () => snapshot ??= this.ruleEngine.snapshot();
+    const explicitEffect = evaluateRules(rules(), toolName, content);
+    if (explicitEffect === "deny" || explicitEffect === "ask") {
+      return { effect: explicitEffect, reason: `Permission rule: ${explicitEffect}` };
+    }
     if (this.mode === "plan" && (toolName === "WriteFile" || toolName === "EditFile")) {
       const path = strArg(args, "file_path", "");
-      if (path.includes(".swifty/plans/")) {
+      if (this.planFilePath && canonicalPath(resolve2(this.workDir, path)) === canonicalPath(resolve2(this.workDir, this.planFilePath)) && !this.sandbox.checkDenyWrite(path)) {
         return {
           effect: "allow",
           reason: "Plan file write allowed in plan mode"
@@ -377,13 +421,13 @@ var PermissionChecker = class {
     const isFilePath = toolName === "ReadFile" || toolName === "WriteFile" || toolName === "EditFile";
     let pattern;
     if (isFilePath && content) {
-      const abs = resolve(content);
+      const abs = resolve2(this.workDir, content);
       let isDir = false;
       try {
         isDir = statSync(abs).isDirectory();
       } catch {
       }
-      pattern = join(isDir ? abs : dirname(abs), "*");
+      pattern = join2(isDir ? abs : dirname2(abs), "*");
     } else {
       const words = content.trim().split(/\s+/).slice(0, 2);
       pattern = words.join(" ") + "*";
@@ -417,6 +461,8 @@ var PermissionChecker = class {
 };
 
 export {
+  canonicalPath,
+  isPathWithin,
   extractContent,
   PathSandbox,
   evaluateRules,