@caspian2026/agent-sdk 0.0.2

package/dist/chunk-26hg7303.js

@@ -0,0 +1,62 @@
+// @bun
+import {
+  getDefaultSubagentModel,
+  init_agent
+} from "./chunk-vzgkedm9.js";
+import {
+  getSourceDisplayName,
+  init_constants
+} from "./chunk-tp2jxmcx.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/tools/AgentTool/agentDisplay.ts
+function resolveAgentOverrides(allAgents, activeAgents) {
+  const activeMap = new Map;
+  for (const agent of activeAgents) {
+    activeMap.set(agent.agentType, agent);
+  }
+  const seen = new Set;
+  const resolved = [];
+  for (const agent of allAgents) {
+    const key = `${agent.agentType}:${agent.source}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    const active = activeMap.get(agent.agentType);
+    const overriddenBy = active && active.source !== agent.source ? active.source : undefined;
+    resolved.push({ ...agent, overriddenBy });
+  }
+  return resolved;
+}
+function resolveAgentModelDisplay(agent) {
+  const model = agent.model || getDefaultSubagentModel();
+  if (!model)
+    return;
+  return model === "inherit" ? "inherit" : model;
+}
+function getOverrideSourceLabel(source) {
+  return getSourceDisplayName(source).toLowerCase();
+}
+function compareAgentsByName(a, b) {
+  return a.agentType.localeCompare(b.agentType, undefined, {
+    sensitivity: "base"
+  });
+}
+var AGENT_SOURCE_GROUPS;
+var init_agentDisplay = __esm(() => {
+  init_agent();
+  init_constants();
+  AGENT_SOURCE_GROUPS = [
+    { label: "User agents", source: "userSettings" },
+    { label: "Project agents", source: "projectSettings" },
+    { label: "Local agents", source: "localSettings" },
+    { label: "Managed agents", source: "policySettings" },
+    { label: "Plugin agents", source: "plugin" },
+    { label: "CLI arg agents", source: "flagSettings" },
+    { label: "Built-in agents", source: "built-in" }
+  ];
+});
+
+export { AGENT_SOURCE_GROUPS, resolveAgentOverrides, resolveAgentModelDisplay, getOverrideSourceLabel, compareAgentsByName, init_agentDisplay };

package/dist/chunk-2f21meep.js

@@ -0,0 +1,122 @@
+// @bun
+import {
+  init_analytics
+} from "./chunk-x8d2ehd7.js";
+import {
+  init_debug
+} from "./chunk-phd1qfpc.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/bash/bashParser.ts
+var READY, SPECIAL_VARS, DECL_KEYWORDS, SHELL_KEYWORDS, ARITH_RIGHT_ASSOC;
+var init_bashParser = __esm(() => {
+  READY = Promise.resolve();
+  SPECIAL_VARS = new Set(["?", "$", "@", "*", "#", "-", "!", "_"]);
+  DECL_KEYWORDS = new Set([
+    "export",
+    "declare",
+    "typeset",
+    "readonly",
+    "local"
+  ]);
+  SHELL_KEYWORDS = new Set([
+    "if",
+    "then",
+    "elif",
+    "else",
+    "fi",
+    "while",
+    "until",
+    "for",
+    "in",
+    "do",
+    "done",
+    "case",
+    "esac",
+    "function",
+    "select"
+  ]);
+  ARITH_RIGHT_ASSOC = new Set([
+    "=",
+    "+=",
+    "-=",
+    "*=",
+    "/=",
+    "%=",
+    "<<=",
+    ">>=",
+    "&=",
+    "^=",
+    "|=",
+    "**"
+  ]);
+});
+
+// src/utils/bash/parser.ts
+async function ensureInitialized() {
+  if (false) {}
+}
+async function parseCommand(command) {
+  if (!command || command.length > MAX_COMMAND_LENGTH)
+    return null;
+  if (false) {}
+  return null;
+}
+async function parseCommandRaw(command) {
+  if (!command || command.length > MAX_COMMAND_LENGTH)
+    return null;
+  if (false) {}
+  return null;
+}
+function extractCommandArguments(commandNode) {
+  if (commandNode.type === "declaration_command") {
+    const firstChild = commandNode.children[0];
+    return firstChild && DECLARATION_COMMANDS.has(firstChild.text) ? [firstChild.text] : [];
+  }
+  const args = [];
+  let foundCommandName = false;
+  for (const child of commandNode.children) {
+    if (child.type === "variable_assignment")
+      continue;
+    if (child.type === "command_name" || !foundCommandName && child.type === "word") {
+      foundCommandName = true;
+      args.push(child.text);
+      continue;
+    }
+    if (ARGUMENT_TYPES.has(child.type)) {
+      args.push(stripQuotes(child.text));
+    } else if (SUBSTITUTION_TYPES.has(child.type)) {
+      break;
+    }
+  }
+  return args;
+}
+function stripQuotes(text) {
+  return text.length >= 2 && (text[0] === '"' && text.at(-1) === '"' || text[0] === "'" && text.at(-1) === "'") ? text.slice(1, -1) : text;
+}
+var MAX_COMMAND_LENGTH = 1e4, DECLARATION_COMMANDS, ARGUMENT_TYPES, SUBSTITUTION_TYPES, COMMAND_TYPES, PARSE_ABORTED;
+var init_parser = __esm(() => {
+  init_analytics();
+  init_debug();
+  init_bashParser();
+  DECLARATION_COMMANDS = new Set([
+    "export",
+    "declare",
+    "typeset",
+    "readonly",
+    "local",
+    "unset",
+    "unsetenv"
+  ]);
+  ARGUMENT_TYPES = new Set(["word", "string", "raw_string", "number"]);
+  SUBSTITUTION_TYPES = new Set([
+    "command_substitution",
+    "process_substitution"
+  ]);
+  COMMAND_TYPES = new Set(["command", "declaration_command"]);
+  PARSE_ABORTED = Symbol("parse-aborted");
+});
+
+export { SHELL_KEYWORDS, init_bashParser, ensureInitialized, parseCommand, PARSE_ABORTED, parseCommandRaw, extractCommandArguments, init_parser };

package/dist/chunk-2fwze72g.js

@@ -0,0 +1,24 @@
+// @bun
+import"./chunk-qp2qdcda.js";
+
+// src/cli/handlers/ant.ts
+var logHandler = async () => {};
+var errorHandler = async () => {};
+var exportHandler = async () => {};
+var taskCreateHandler = async () => {};
+var taskListHandler = async () => {};
+var taskGetHandler = async () => {};
+var taskUpdateHandler = async () => {};
+var taskDirHandler = async () => {};
+var completionHandler = async () => {};
+export {
+  taskUpdateHandler,
+  taskListHandler,
+  taskGetHandler,
+  taskDirHandler,
+  taskCreateHandler,
+  logHandler,
+  exportHandler,
+  errorHandler,
+  completionHandler
+};

package/dist/chunk-2gzv8nrw.js

@@ -0,0 +1,205 @@
+// @bun
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/p-map@7.0.4/node_modules/p-map/index.js
+async function pMap(iterable, mapper, {
+  concurrency = Number.POSITIVE_INFINITY,
+  stopOnError = true,
+  signal
+} = {}) {
+  return new Promise((resolve_, reject_) => {
+    if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
+      throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`);
+    }
+    if (typeof mapper !== "function") {
+      throw new TypeError("Mapper function is required");
+    }
+    if (!(Number.isSafeInteger(concurrency) && concurrency >= 1 || concurrency === Number.POSITIVE_INFINITY)) {
+      throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
+    }
+    const result = [];
+    const errors = [];
+    const skippedIndexesMap = new Map;
+    let isRejected = false;
+    let isResolved = false;
+    let isIterableDone = false;
+    let resolvingCount = 0;
+    let currentIndex = 0;
+    const iterator = iterable[Symbol.iterator] === undefined ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
+    const signalListener = () => {
+      reject(signal.reason);
+    };
+    const cleanup = () => {
+      signal?.removeEventListener("abort", signalListener);
+    };
+    const resolve = (value) => {
+      resolve_(value);
+      cleanup();
+    };
+    const reject = (reason) => {
+      isRejected = true;
+      isResolved = true;
+      reject_(reason);
+      cleanup();
+    };
+    if (signal) {
+      if (signal.aborted) {
+        reject(signal.reason);
+      }
+      signal.addEventListener("abort", signalListener, { once: true });
+    }
+    const next = async () => {
+      if (isResolved) {
+        return;
+      }
+      const nextItem = await iterator.next();
+      const index = currentIndex;
+      currentIndex++;
+      if (nextItem.done) {
+        isIterableDone = true;
+        if (resolvingCount === 0 && !isResolved) {
+          if (!stopOnError && errors.length > 0) {
+            reject(new AggregateError(errors));
+            return;
+          }
+          isResolved = true;
+          if (skippedIndexesMap.size === 0) {
+            resolve(result);
+            return;
+          }
+          const pureResult = [];
+          for (const [index2, value] of result.entries()) {
+            if (skippedIndexesMap.get(index2) === pMapSkip) {
+              continue;
+            }
+            pureResult.push(value);
+          }
+          resolve(pureResult);
+        }
+        return;
+      }
+      resolvingCount++;
+      (async () => {
+        try {
+          const element = await nextItem.value;
+          if (isResolved) {
+            return;
+          }
+          const value = await mapper(element, index);
+          if (value === pMapSkip) {
+            skippedIndexesMap.set(index, value);
+          }
+          result[index] = value;
+          resolvingCount--;
+          await next();
+        } catch (error) {
+          if (stopOnError) {
+            reject(error);
+          } else {
+            errors.push(error);
+            resolvingCount--;
+            try {
+              await next();
+            } catch (error2) {
+              reject(error2);
+            }
+          }
+        }
+      })();
+    };
+    (async () => {
+      for (let index = 0;index < concurrency; index++) {
+        try {
+          await next();
+        } catch (error) {
+          reject(error);
+          break;
+        }
+        if (isIterableDone || isRejected) {
+          break;
+        }
+      }
+    })();
+  });
+}
+function pMapIterable(iterable, mapper, {
+  concurrency = Number.POSITIVE_INFINITY,
+  backpressure = concurrency
+} = {}) {
+  if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
+    throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`);
+  }
+  if (typeof mapper !== "function") {
+    throw new TypeError("Mapper function is required");
+  }
+  if (!(Number.isSafeInteger(concurrency) && concurrency >= 1 || concurrency === Number.POSITIVE_INFINITY)) {
+    throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
+  }
+  if (!(Number.isSafeInteger(backpressure) && backpressure >= concurrency || backpressure === Number.POSITIVE_INFINITY)) {
+    throw new TypeError(`Expected \`backpressure\` to be an integer from \`concurrency\` (${concurrency}) and up or \`Infinity\`, got \`${backpressure}\` (${typeof backpressure})`);
+  }
+  return {
+    async* [Symbol.asyncIterator]() {
+      const iterator = iterable[Symbol.asyncIterator] === undefined ? iterable[Symbol.iterator]() : iterable[Symbol.asyncIterator]();
+      const promises = [];
+      let pendingPromisesCount = 0;
+      let isDone = false;
+      let index = 0;
+      function trySpawn() {
+        if (isDone || !(pendingPromisesCount < concurrency && promises.length < backpressure)) {
+          return;
+        }
+        pendingPromisesCount++;
+        const promise = (async () => {
+          const { done, value } = await iterator.next();
+          if (done) {
+            pendingPromisesCount--;
+            return { done: true };
+          }
+          trySpawn();
+          try {
+            const returnValue = await mapper(await value, index++);
+            pendingPromisesCount--;
+            if (returnValue === pMapSkip) {
+              const index2 = promises.indexOf(promise);
+              if (index2 > 0) {
+                promises.splice(index2, 1);
+              }
+            }
+            trySpawn();
+            return { done: false, value: returnValue };
+          } catch (error) {
+            pendingPromisesCount--;
+            isDone = true;
+            return { error };
+          }
+        })();
+        promises.push(promise);
+      }
+      trySpawn();
+      while (promises.length > 0) {
+        const { error, done, value } = await promises[0];
+        promises.shift();
+        if (error) {
+          throw error;
+        }
+        if (done) {
+          return;
+        }
+        trySpawn();
+        if (value === pMapSkip) {
+          continue;
+        }
+        yield value;
+      }
+    }
+  };
+}
+var pMapSkip;
+var init_p_map = __esm(() => {
+  pMapSkip = Symbol("skip");
+});
+
+export { pMap, pMapIterable, pMapSkip, init_p_map };

package/dist/chunk-2h05vtpv.js

@@ -0,0 +1,83 @@
+// @bun
+import {
+  extractConversationText,
+  init_sessionTitle
+} from "./chunk-nw9t5pq9.js";
+import {
+  asSystemPrompt,
+  extractTextContent,
+  init_claude,
+  init_messages1 as init_messages,
+  init_systemPromptType,
+  queryHaiku
+} from "./chunk-vzgkedm9.js";
+import {
+  init_json,
+  safeParseJSON
+} from "./chunk-z19sd3bt.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  logForDebugging
+} from "./chunk-phd1qfpc.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/rename/generateSessionName.ts
+async function generateSessionName(messages, signal) {
+  const conversationText = extractConversationText(messages);
+  if (!conversationText) {
+    return null;
+  }
+  try {
+    const result = await queryHaiku({
+      systemPrompt: asSystemPrompt([
+        'Generate a short kebab-case name (2-4 words) that captures the main topic of this conversation. Use lowercase words separated by hyphens. Examples: "fix-login-bug", "add-auth-feature", "refactor-api-client", "debug-test-failures". Return JSON with a "name" field.'
+      ]),
+      userPrompt: conversationText,
+      outputFormat: {
+        type: "json_schema",
+        schema: {
+          type: "object",
+          properties: {
+            name: { type: "string" }
+          },
+          required: ["name"],
+          additionalProperties: false
+        }
+      },
+      signal,
+      options: {
+        querySource: "rename_generate_name",
+        agents: [],
+        isNonInteractiveSession: false,
+        hasAppendSystemPrompt: false,
+        mcpTools: []
+      }
+    });
+    const content = Array.isArray(result.message.content) ? extractTextContent(result.message.content) : result.message.content;
+    const response = safeParseJSON(content);
+    if (response && typeof response === "object" && "name" in response && typeof response.name === "string") {
+      return response.name;
+    }
+    return null;
+  } catch (error) {
+    logForDebugging(`generateSessionName failed: ${errorMessage(error)}`, {
+      level: "error"
+    });
+    return null;
+  }
+}
+var init_generateSessionName = __esm(() => {
+  init_claude();
+  init_debug();
+  init_errors();
+  init_json();
+  init_messages();
+  init_sessionTitle();
+  init_systemPromptType();
+});
+
+export { generateSessionName, init_generateSessionName };