@costrict/csc 4.0.1

package/dist/chunk-w0nwhqww.js

@@ -0,0 +1,295 @@
+// @bun
+import {
+  getDirectoryCompletions,
+  init_directoryCompletion
+} from "./chunk-vp8cvspq.js";
+import {
+  PromptInputFooterSuggestions,
+  init_PromptInputFooterSuggestions
+} from "./chunk-qwcs5mar.js";
+import {
+  ConfigurableShortcutHint,
+  Select,
+  TextInput,
+  addDirHelpMessage,
+  init_ConfigurableShortcutHint,
+  init_TextInput,
+  init_select,
+  init_validation,
+  validateDirectoryForWorkspace
+} from "./chunk-97kwfkef.js";
+import {
+  init_useKeybinding
+} from "./chunk-3z9478wf.js";
+import {
+  Byline,
+  Dialog,
+  KeyboardShortcutHint,
+  ThemedBox_default,
+  ThemedText,
+  init_dist,
+  init_src,
+  useDebounceCallback,
+  useKeybinding
+} from "./chunk-fk80f449.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  figures_default,
+  init_figures
+} from "./chunk-qajrkk97.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/components/permissions/rules/AddWorkspaceDirectory.tsx
+function PermissionDescription() {
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+    dimColor: true,
+    children: "CoStrict will be able to read files in this directory and make edits when auto-accept edits is on."
+  }, undefined, false, undefined, this);
+}
+function DirectoryDisplay({ path }) {
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+    flexDirection: "column",
+    paddingX: 2,
+    gap: 1,
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        color: "permission",
+        children: path
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(PermissionDescription, {}, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function DirectoryInput({
+  value,
+  onChange,
+  onSubmit,
+  error,
+  suggestions,
+  selectedSuggestion
+}) {
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        children: "Enter the path to the directory:"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+        borderDimColor: true,
+        borderStyle: "round",
+        marginY: 1,
+        paddingLeft: 1,
+        children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(TextInput, {
+          showCursor: true,
+          placeholder: `Directory path${figures_default.ellipsis}`,
+          value,
+          onChange,
+          onSubmit,
+          columns: 80,
+          cursorOffset: value.length,
+          onChangeCursorOffset: () => {}
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      suggestions.length > 0 && /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+        marginBottom: 1,
+        children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(PromptInputFooterSuggestions, {
+          suggestions,
+          selectedSuggestion
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      error && /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        color: "error",
+        children: error
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function AddWorkspaceDirectory({
+  onAddDirectory,
+  onCancel,
+  permissionContext,
+  directoryPath
+}) {
+  const [directoryInput, setDirectoryInput] = import_react.useState("");
+  const [error, setError] = import_react.useState(null);
+  const [suggestions, setSuggestions] = import_react.useState([]);
+  const [selectedSuggestion, setSelectedSuggestion] = import_react.useState(0);
+  const options = import_react.useMemo(() => REMEMBER_DIRECTORY_OPTIONS, []);
+  const fetchSuggestions = import_react.useCallback(async (path) => {
+    if (!path) {
+      setSuggestions([]);
+      setSelectedSuggestion(0);
+      return;
+    }
+    const completions = await getDirectoryCompletions(path);
+    setSuggestions(completions);
+    setSelectedSuggestion(0);
+  }, []);
+  const debouncedFetchSuggestions = useDebounceCallback(fetchSuggestions, 100);
+  import_react.useEffect(() => {
+    debouncedFetchSuggestions(directoryInput);
+  }, [directoryInput, debouncedFetchSuggestions]);
+  const applySuggestion = import_react.useCallback((suggestion) => {
+    const newPath = suggestion.id + "/";
+    setDirectoryInput(newPath);
+    setError(null);
+  }, []);
+  const handleSubmit = import_react.useCallback(async (newPath) => {
+    const result = await validateDirectoryForWorkspace(newPath, permissionContext);
+    if (result.resultType === "success") {
+      onAddDirectory(result.absolutePath, false);
+    } else {
+      setError(addDirHelpMessage(result));
+    }
+  }, [permissionContext, onAddDirectory]);
+  useKeybinding("confirm:no", onCancel, { context: "Settings" });
+  const handleKeyDown = import_react.useCallback((e) => {
+    if (suggestions.length > 0) {
+      if (e.key === "tab") {
+        e.preventDefault();
+        const suggestion = suggestions[selectedSuggestion];
+        if (suggestion) {
+          applySuggestion(suggestion);
+        }
+        return;
+      }
+      if (e.key === "return") {
+        e.preventDefault();
+        const suggestion = suggestions[selectedSuggestion];
+        if (suggestion) {
+          handleSubmit(suggestion.id + "/");
+        }
+        return;
+      }
+      if (e.key === "up" || e.ctrl && e.key === "p") {
+        e.preventDefault();
+        setSelectedSuggestion((prev) => prev <= 0 ? suggestions.length - 1 : prev - 1);
+        return;
+      }
+      if (e.key === "down" || e.ctrl && e.key === "n") {
+        e.preventDefault();
+        setSelectedSuggestion((prev) => prev >= suggestions.length - 1 ? 0 : prev + 1);
+        return;
+      }
+    }
+  }, [suggestions, selectedSuggestion, applySuggestion, handleSubmit]);
+  const handleSelect = import_react.useCallback((value) => {
+    if (!directoryPath)
+      return;
+    const selectionValue = value;
+    switch (selectionValue) {
+      case "yes-session":
+        onAddDirectory(directoryPath, false);
+        break;
+      case "yes-remember":
+        onAddDirectory(directoryPath, true);
+        break;
+      case "no":
+        onCancel();
+        break;
+    }
+  }, [directoryPath, onAddDirectory, onCancel]);
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+    flexDirection: "column",
+    tabIndex: 0,
+    autoFocus: true,
+    onKeyDown: handleKeyDown,
+    children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Dialog, {
+      title: "Add directory to workspace",
+      onCancel,
+      color: "permission",
+      isCancelActive: false,
+      inputGuide: directoryPath ? undefined : (exitState) => exitState.pending ? /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        children: [
+          "Press ",
+          exitState.keyName,
+          " again to exit"
+        ]
+      }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Byline, {
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(KeyboardShortcutHint, {
+            shortcut: "Tab",
+            action: "complete"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(KeyboardShortcutHint, {
+            shortcut: "Enter",
+            action: "add"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ConfigurableShortcutHint, {
+            action: "confirm:no",
+            context: "Settings",
+            fallback: "Esc",
+            description: "cancel"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      children: directoryPath ? /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+        flexDirection: "column",
+        gap: 1,
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(DirectoryDisplay, {
+            path: directoryPath
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Select, {
+            options,
+            onChange: handleSelect,
+            onCancel: () => handleSelect("no")
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+        flexDirection: "column",
+        gap: 1,
+        marginX: 2,
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(PermissionDescription, {}, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(DirectoryInput, {
+            value: directoryInput,
+            onChange: setDirectoryInput,
+            onSubmit: handleSubmit,
+            error,
+            suggestions,
+            selectedSuggestion
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+var import_react, jsx_dev_runtime, REMEMBER_DIRECTORY_OPTIONS;
+var init_AddWorkspaceDirectory = __esm(() => {
+  init_figures();
+  init_dist();
+  init_validation();
+  init_TextInput();
+  init_src();
+  init_useKeybinding();
+  init_directoryCompletion();
+  init_ConfigurableShortcutHint();
+  init_select();
+  init_src();
+  init_PromptInputFooterSuggestions();
+  import_react = __toESM(require_react(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+  REMEMBER_DIRECTORY_OPTIONS = [
+    {
+      value: "yes-session",
+      label: "Yes, for this session"
+    },
+    {
+      value: "yes-remember",
+      label: "Yes, and remember this directory"
+    },
+    {
+      value: "no",
+      label: "No"
+    }
+  ];
+});
+
+export { AddWorkspaceDirectory, init_AddWorkspaceDirectory };

package/dist/chunk-w32xjs44.js

@@ -0,0 +1,306 @@
+// @bun
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/services/api/openai/convertTools.ts
+function anthropicToolsToOpenAI(tools) {
+  return tools.filter((tool) => {
+    const toolType = tool.type;
+    return tool.type === "custom" || !("type" in tool) || toolType !== "server";
+  }).map((tool) => {
+    const anyTool = tool;
+    const name = anyTool.name || "";
+    const description = anyTool.description || "";
+    const inputSchema = anyTool.input_schema;
+    return {
+      type: "function",
+      function: {
+        name,
+        description,
+        parameters: sanitizeJsonSchema(inputSchema || { type: "object", properties: {} })
+      }
+    };
+  });
+}
+function sanitizeJsonSchema(schema) {
+  if (!schema || typeof schema !== "object")
+    return schema;
+  const result = { ...schema };
+  if ("const" in result) {
+    result.enum = [result.const];
+    delete result.const;
+  }
+  const objectKeys = ["properties", "definitions", "$defs", "patternProperties"];
+  for (const key of objectKeys) {
+    const nested = result[key];
+    if (nested && typeof nested === "object") {
+      const sanitized = {};
+      for (const [k, v] of Object.entries(nested)) {
+        sanitized[k] = v && typeof v === "object" ? sanitizeJsonSchema(v) : v;
+      }
+      result[key] = sanitized;
+    }
+  }
+  const singleKeys = ["items", "additionalProperties", "not", "if", "then", "else", "contains", "propertyNames"];
+  for (const key of singleKeys) {
+    const nested = result[key];
+    if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+      result[key] = sanitizeJsonSchema(nested);
+    }
+  }
+  const arrayKeys = ["anyOf", "oneOf", "allOf"];
+  for (const key of arrayKeys) {
+    const nested = result[key];
+    if (Array.isArray(nested)) {
+      result[key] = nested.map((item) => item && typeof item === "object" ? sanitizeJsonSchema(item) : item);
+    }
+  }
+  return result;
+}
+function anthropicToolChoiceToOpenAI(toolChoice) {
+  if (!toolChoice || typeof toolChoice !== "object")
+    return;
+  const tc = toolChoice;
+  const type = tc.type;
+  switch (type) {
+    case "auto":
+      return "auto";
+    case "any":
+      return "required";
+    case "tool":
+      return {
+        type: "function",
+        function: { name: tc.name }
+      };
+    default:
+      return;
+  }
+}
+var init_convertTools = () => {};
+
+// src/services/api/openai/streamAdapter.ts
+import { randomUUID } from "crypto";
+async function* adaptOpenAIStreamToAnthropic(stream, model) {
+  const messageId = `msg_${randomUUID().replace(/-/g, "").slice(0, 24)}`;
+  let started = false;
+  let currentContentIndex = -1;
+  const toolBlocks = new Map;
+  let thinkingBlockOpen = false;
+  let textBlockOpen = false;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cachedTokens = 0;
+  const openBlockIndices = new Set;
+  for await (const chunk of stream) {
+    const choice = chunk.choices?.[0];
+    const delta = choice?.delta;
+    if (chunk.usage) {
+      inputTokens = chunk.usage.prompt_tokens ?? inputTokens;
+      outputTokens = chunk.usage.completion_tokens ?? outputTokens;
+      const details = chunk.usage.prompt_tokens_details;
+      if (details?.cached_tokens) {
+        cachedTokens = details.cached_tokens;
+      }
+    }
+    if (!started) {
+      started = true;
+      yield {
+        type: "message_start",
+        message: {
+          id: messageId,
+          type: "message",
+          role: "assistant",
+          content: [],
+          model,
+          stop_reason: null,
+          stop_sequence: null,
+          usage: {
+            input_tokens: inputTokens,
+            output_tokens: 0,
+            cache_creation_input_tokens: 0,
+            cache_read_input_tokens: cachedTokens
+          }
+        }
+      };
+    }
+    if (!delta)
+      continue;
+    const reasoningContent = delta.reasoning_content;
+    if (reasoningContent != null && reasoningContent !== "") {
+      if (!thinkingBlockOpen) {
+        currentContentIndex++;
+        thinkingBlockOpen = true;
+        openBlockIndices.add(currentContentIndex);
+        yield {
+          type: "content_block_start",
+          index: currentContentIndex,
+          content_block: {
+            type: "thinking",
+            thinking: "",
+            signature: ""
+          }
+        };
+      }
+      yield {
+        type: "content_block_delta",
+        index: currentContentIndex,
+        delta: {
+          type: "thinking_delta",
+          thinking: reasoningContent
+        }
+      };
+    }
+    if (delta.content != null && delta.content !== "") {
+      if (!textBlockOpen) {
+        if (thinkingBlockOpen) {
+          yield {
+            type: "content_block_stop",
+            index: currentContentIndex
+          };
+          openBlockIndices.delete(currentContentIndex);
+          thinkingBlockOpen = false;
+        }
+        currentContentIndex++;
+        textBlockOpen = true;
+        openBlockIndices.add(currentContentIndex);
+        yield {
+          type: "content_block_start",
+          index: currentContentIndex,
+          content_block: {
+            type: "text",
+            text: ""
+          }
+        };
+      }
+      yield {
+        type: "content_block_delta",
+        index: currentContentIndex,
+        delta: {
+          type: "text_delta",
+          text: delta.content
+        }
+      };
+    }
+    if (delta.tool_calls) {
+      for (const tc of delta.tool_calls) {
+        const tcIndex = tc.index;
+        if (!toolBlocks.has(tcIndex)) {
+          if (thinkingBlockOpen) {
+            yield {
+              type: "content_block_stop",
+              index: currentContentIndex
+            };
+            openBlockIndices.delete(currentContentIndex);
+            thinkingBlockOpen = false;
+          }
+          if (textBlockOpen) {
+            yield {
+              type: "content_block_stop",
+              index: currentContentIndex
+            };
+            openBlockIndices.delete(currentContentIndex);
+            textBlockOpen = false;
+          }
+          currentContentIndex++;
+          const toolId = tc.id || `toolu_${randomUUID().replace(/-/g, "").slice(0, 24)}`;
+          const toolName = tc.function?.name || "";
+          toolBlocks.set(tcIndex, {
+            contentIndex: currentContentIndex,
+            id: toolId,
+            name: toolName,
+            arguments: ""
+          });
+          openBlockIndices.add(currentContentIndex);
+          yield {
+            type: "content_block_start",
+            index: currentContentIndex,
+            content_block: {
+              type: "tool_use",
+              id: toolId,
+              name: toolName,
+              input: {}
+            }
+          };
+        }
+        const argFragment = tc.function?.arguments;
+        if (argFragment) {
+          toolBlocks.get(tcIndex).arguments += argFragment;
+          yield {
+            type: "content_block_delta",
+            index: toolBlocks.get(tcIndex).contentIndex,
+            delta: {
+              type: "input_json_delta",
+              partial_json: argFragment
+            }
+          };
+        }
+      }
+    }
+    if (choice?.finish_reason) {
+      if (thinkingBlockOpen) {
+        yield {
+          type: "content_block_stop",
+          index: currentContentIndex
+        };
+        openBlockIndices.delete(currentContentIndex);
+        thinkingBlockOpen = false;
+      }
+      if (textBlockOpen) {
+        yield {
+          type: "content_block_stop",
+          index: currentContentIndex
+        };
+        openBlockIndices.delete(currentContentIndex);
+        textBlockOpen = false;
+      }
+      for (const [, block] of toolBlocks) {
+        if (openBlockIndices.has(block.contentIndex)) {
+          yield {
+            type: "content_block_stop",
+            index: block.contentIndex
+          };
+          openBlockIndices.delete(block.contentIndex);
+        }
+      }
+      const hasToolCalls = toolBlocks.size > 0;
+      const stopReason = hasToolCalls ? "tool_use" : mapFinishReason(choice.finish_reason);
+      yield {
+        type: "message_delta",
+        delta: {
+          stop_reason: stopReason,
+          stop_sequence: null
+        },
+        usage: {
+          output_tokens: outputTokens
+        }
+      };
+      yield {
+        type: "message_stop"
+      };
+    }
+  }
+  for (const idx of openBlockIndices) {
+    yield {
+      type: "content_block_stop",
+      index: idx
+    };
+  }
+}
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "stop":
+      return "end_turn";
+    case "tool_calls":
+      return "tool_use";
+    case "length":
+      return "max_tokens";
+    case "content_filter":
+      return "end_turn";
+    default:
+      return "end_turn";
+  }
+}
+var init_streamAdapter = () => {};
+
+export { anthropicToolsToOpenAI, anthropicToolChoiceToOpenAI, init_convertTools, adaptOpenAIStreamToAnthropic, init_streamAdapter };

package/dist/chunk-w4mdb23d.js

@@ -0,0 +1,111 @@
+// @bun
+import {
+  Messages,
+  init_Messages
+} from "./chunk-hqhmy4sg.js";
+import {
+  init_staticRender,
+  renderToAnsiString
+} from "./chunk-fzsn5y4x.js";
+import {
+  AppStateProvider,
+  init_AppState,
+  init_KeybindingContext,
+  init_loadUserBindings,
+  loadKeybindingsSyncWithWarnings
+} from "./chunk-97kwfkef.js";
+import {
+  KeybindingProvider,
+  init_strip_ansi,
+  stripAnsi
+} from "./chunk-fk80f449.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/exportRenderer.tsx
+function StaticKeybindingProvider({
+  children
+}) {
+  const { bindings } = loadKeybindingsSyncWithWarnings();
+  const pendingChordRef = import_react.useRef(null);
+  const handlerRegistryRef = import_react.useRef(new Map);
+  const activeContexts = import_react.useRef(new Set).current;
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(KeybindingProvider, {
+    bindings,
+    pendingChordRef,
+    pendingChord: null,
+    setPendingChord: () => {},
+    activeContexts,
+    registerActiveContext: () => {},
+    unregisterActiveContext: () => {},
+    handlerRegistryRef,
+    children
+  }, undefined, false, undefined, this);
+}
+function normalizedUpperBound(m) {
+  if (!("message" in m))
+    return 1;
+  const c = m.message.content;
+  return Array.isArray(c) ? c.length : 1;
+}
+async function streamRenderedMessages(messages, tools, sink, {
+  columns,
+  verbose = false,
+  chunkSize = 40,
+  onProgress
+} = {}) {
+  const renderChunk = (range) => renderToAnsiString(/* @__PURE__ */ jsx_dev_runtime.jsxDEV(AppStateProvider, {
+    children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(StaticKeybindingProvider, {
+      children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Messages, {
+        messages,
+        tools,
+        commands: [],
+        verbose,
+        toolJSX: null,
+        toolUseConfirmQueue: [],
+        inProgressToolUseIDs: new Set,
+        isMessageSelectorVisible: false,
+        conversationId: "export",
+        screen: "prompt",
+        streamingToolUses: [],
+        showAllInTranscript: true,
+        isLoading: false,
+        renderRange: range
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this), columns);
+  let ceiling = chunkSize;
+  for (const m of messages)
+    ceiling += normalizedUpperBound(m);
+  for (let offset = 0;offset < ceiling; offset += chunkSize) {
+    const ansi = await renderChunk([offset, offset + chunkSize]);
+    if (stripAnsi(ansi).trim() === "")
+      break;
+    await sink(ansi);
+    onProgress?.(offset + chunkSize);
+  }
+}
+async function renderMessagesToPlainText(messages, tools = [], columns) {
+  const parts = [];
+  await streamRenderedMessages(messages, tools, (chunk) => void parts.push(stripAnsi(chunk)), { columns });
+  return parts.join("");
+}
+var import_react, jsx_dev_runtime;
+var init_exportRenderer = __esm(() => {
+  init_strip_ansi();
+  init_Messages();
+  init_KeybindingContext();
+  init_loadUserBindings();
+  init_AppState();
+  init_staticRender();
+  import_react = __toESM(require_react(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+export { renderMessagesToPlainText, init_exportRenderer };