@wrongstack/core 0.313.0 → 0.313.1

package/dist/chunk-WEBMSQP2.js

@@ -0,0 +1,123 @@
+// src/skills/frontmatter.ts
+var SCALAR_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "trigger",
+  "version",
+  "license",
+  "compatibility"
+]);
+function parseSkillFrontmatter(raw) {
+  const text = normalizeLineEndings(raw);
+  if (!text.startsWith("---")) return {};
+  const end = text.indexOf("\n---", 4);
+  if (end === -1) return {};
+  return parseFrontmatterBlock(text.slice(4, end));
+}
+function stripFrontmatter(raw) {
+  const text = normalizeLineEndings(raw);
+  if (!text.startsWith("---")) return text;
+  const end = text.indexOf("\n---", 4);
+  if (end === -1) return text;
+  let body = text.slice(end + 4);
+  if (body.startsWith("\n")) body = body.slice(1);
+  return body;
+}
+function normalizeLineEndings(s) {
+  return s.replace(/\r\n?/g, "\n");
+}
+function parseFrontmatterBlock(block) {
+  const out = {};
+  const lines = block.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const m = /^([a-zA-Z][a-zA-Z0-9_-]*):\s*(.*)$/.exec(line);
+    if (!m) {
+      i++;
+      continue;
+    }
+    const key = m[1] ?? "";
+    const rest = (m[2] ?? "").trim();
+    if (key === "metadata") {
+      const map = {};
+      i++;
+      while (i < lines.length) {
+        const sub = lines[i] ?? "";
+        const sm = /^\s+([a-zA-Z0-9_.-]+):\s*(.*)$/.exec(sub);
+        if (!sm) break;
+        map[sm[1] ?? ""] = unquote((sm[2] ?? "").trim());
+        i++;
+      }
+      if (Object.keys(map).length > 0) out.metadata = map;
+      continue;
+    }
+    if (rest === "|" || rest === ">") {
+      const collected = [];
+      i++;
+      while (i < lines.length) {
+        const sub = lines[i] ?? "";
+        if (sub === "" || sub.startsWith(" ") || sub.startsWith("	")) {
+          collected.push(sub.replace(/^\s+/, ""));
+          i++;
+        } else break;
+      }
+      out[normalizeKey(key)] = collected.join("\n").trim();
+      continue;
+    }
+    if (key === "allowed-tools" || key === "allowedTools" || key === "required-capabilities" || key === "requiredCapabilities" || key === "required-tools" || key === "requiredTools" || key === "optional-capabilities" || key === "optionalCapabilities") {
+      const values = rest.replace(/^\[/, "").replace(/\]$/, "").split(/[\s,]+/).map(unquote).filter(Boolean);
+      out[normalizeKey(key)] = values;
+      i++;
+      continue;
+    }
+    if (SCALAR_KEYS.has(key)) {
+      out[key] = unquote(rest);
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return out;
+}
+function normalizeKey(key) {
+  if (key === "allowed-tools") return "allowedTools";
+  if (key === "required-capabilities") return "requiredCapabilities";
+  if (key === "required-tools") return "requiredTools";
+  if (key === "optional-capabilities") return "optionalCapabilities";
+  return key;
+}
+function unquote(s) {
+  if (s.length >= 2 && (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'"))) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function isValidSkillNameFormat(name) {
+  return name.length >= 1 && name.length <= 64 && /^[a-z0-9]+(-[a-z0-9]+)*$/.test(name);
+}
+function validateSkillName(name, parentDirName) {
+  const errors = [];
+  if (!name || name.trim().length === 0) {
+    errors.push("name is empty");
+    return errors;
+  }
+  if (name.length > 64) errors.push(`name is ${name.length} characters (max 64)`);
+  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(name)) {
+    errors.push(
+      "name must be lowercase letters, digits, and single hyphens only (no leading/trailing/consecutive hyphens)"
+    );
+  }
+  if (parentDirName !== void 0 && name !== parentDirName) {
+    errors.push(`name "${name}" must match its parent directory "${parentDirName}"`);
+  }
+  return errors;
+}
+
+export {
+  parseSkillFrontmatter,
+  stripFrontmatter,
+  isValidSkillNameFormat,
+  validateSkillName
+};
+//# sourceMappingURL=chunk-WEBMSQP2.js.map

package/dist/chunk-WOEZV3Q4.js

@@ -0,0 +1,333 @@
+import {
+  toErrorMessage
+} from "./chunk-TBRL2RCC.js";
+
+// src/types/errors.ts
+var ERROR_CODES = {
+  // Provider
+  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
+  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
+  PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED",
+  PROVIDER_INVALID_REQUEST: "PROVIDER_INVALID_REQUEST",
+  PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
+  PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR",
+  PROVIDER_CONTEXT_OVERFLOW: "PROVIDER_CONTEXT_OVERFLOW",
+  // Tool
+  TOOL_NOT_FOUND: "TOOL_NOT_FOUND",
+  TOOL_PERMISSION_DENIED: "TOOL_PERMISSION_DENIED",
+  TOOL_EXECUTION_FAILED: "TOOL_EXECUTION_FAILED",
+  TOOL_TIMEOUT: "TOOL_TIMEOUT",
+  TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
+  // Config
+  CONFIG_INVALID: "CONFIG_INVALID",
+  CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND",
+  CONFIG_PARSE_FAILED: "CONFIG_PARSE_FAILED",
+  CONFIG_MIGRATION_NEEDED: "CONFIG_MIGRATION_NEEDED",
+  // Plugin
+  PLUGIN_LOAD_FAILED: "PLUGIN_LOAD_FAILED",
+  PLUGIN_API_MISMATCH: "PLUGIN_API_MISMATCH",
+  PLUGIN_MISSING_DEPENDENCY: "PLUGIN_MISSING_DEPENDENCY",
+  // Agent
+  AGENT_ITERATION_LIMIT: "AGENT_ITERATION_LIMIT",
+  AGENT_CONTEXT_OVERFLOW: "AGENT_CONTEXT_OVERFLOW",
+  AGENT_ABORTED: "AGENT_ABORTED",
+  AGENT_RUN_FAILED: "AGENT_RUN_FAILED",
+  // Session
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  SESSION_CORRUPTED: "SESSION_CORRUPTED",
+  SESSION_WRITE_FAILED: "SESSION_WRITE_FAILED",
+  // Container / Registry
+  CONTAINER_TOKEN_ALREADY_BOUND: "CONTAINER_TOKEN_ALREADY_BOUND",
+  CONTAINER_TOKEN_NOT_BOUND: "CONTAINER_TOKEN_NOT_BOUND",
+  CONTAINER_CIRCULAR_DEPENDENCY: "CONTAINER_CIRCULAR_DEPENDENCY",
+  REGISTRY_DUPLICATE: "REGISTRY_DUPLICATE",
+  REGISTRY_NOT_FOUND: "REGISTRY_NOT_FOUND",
+  REGISTRY_INVALID: "REGISTRY_INVALID",
+  // File system
+  FS_READ_FAILED: "FS_READ_FAILED",
+  FS_WRITE_FAILED: "FS_WRITE_FAILED",
+  FS_MKDIR_FAILED: "FS_MKDIR_FAILED",
+  FS_DELETE_FAILED: "FS_DELETE_FAILED",
+  FS_ATOMIC_WRITE_FAILED: "FS_ATOMIC_WRITE_FAILED",
+  // SDD (Spec-Driven Development)
+  SDD_VALIDATION_FAILED: "SDD_VALIDATION_FAILED",
+  SDD_PARSE_FAILED: "SDD_PARSE_FAILED",
+  SDD_INVALID_STATE: "SDD_INVALID_STATE",
+  SDD_NOT_READY: "SDD_NOT_READY",
+  // General
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  PARSE_FAILED: "PARSE_FAILED",
+  UNKNOWN: "UNKNOWN"
+};
+var WrongStackError = class _WrongStackError extends Error {
+  code;
+  subsystem;
+  severity;
+  recoverable;
+  context;
+  constructor(opts) {
+    super(opts.message, { cause: opts.cause });
+    this.name = "WrongStackError";
+    this.code = opts.code;
+    this.subsystem = opts.subsystem;
+    this.severity = opts.severity ?? "error";
+    this.recoverable = opts.recoverable ?? false;
+    this.context = opts.context;
+  }
+  /**
+   * Duck-type guard mirroring {@link ProviderError.isProviderError}.
+   *
+   * `instanceof WrongStackError` is NOT reliable inside this monorepo: the
+   * package builder emits every `@wrongstack/core` subpath (`core`, `types`,
+   * `coordination`, `execution`, `extension`, …) as an independent esbuild
+   * bundle with `splitting: false`, so each entry inlines its OWN copy of this
+   * class. An error constructed by `@wrongstack/providers` (which imports from
+   * `@wrongstack/core/types`) therefore fails `instanceof` against the copy
+   * baked into `@wrongstack/core/core` — which is where the agent loop and the
+   * provider runner live.
+   *
+   * That mismatch silently downgraded every provider failure to a generic
+   * `AgentError` in {@link toWrongStackError}, stripping `kind` / `status` /
+   * `body` and blinding the fallback engine and the provider waiting room.
+   * Use this guard anywhere the error may have crossed a subpath boundary.
+   */
+  static isWrongStackError(err) {
+    if (err instanceof _WrongStackError) return true;
+    if (!err || typeof err !== "object") return false;
+    const e = err;
+    return typeof e["name"] === "string" && e["name"].endsWith("Error") && typeof e["code"] === "string" && typeof e["subsystem"] === "string" && typeof e["severity"] === "string" && typeof e["describe"] === "function";
+  }
+  /**
+   * Render a one-line user-facing description.
+   * Subclasses should override for domain-specific formatting.
+   */
+  describe() {
+    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
+    return `${this.code}: ${this.message}${ctx}`;
+  }
+};
+function formatContext(ctx) {
+  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
+  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
+}
+var ToolError = class extends WrongStackError {
+  toolName;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "tool",
+      recoverable: opts.recoverable,
+      context: { tool: opts.toolName, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "ToolError";
+    this.toolName = opts.toolName;
+  }
+};
+var ConfigError = class extends WrongStackError {
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "config",
+      severity: "fatal",
+      recoverable: false,
+      context: opts.context,
+      cause: opts.cause
+    });
+    this.name = "ConfigError";
+  }
+};
+var PluginError = class extends WrongStackError {
+  pluginName;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "plugin",
+      severity: "error",
+      recoverable: opts.code === ERROR_CODES.PLUGIN_MISSING_DEPENDENCY,
+      context: { plugin: opts.pluginName, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "PluginError";
+    this.pluginName = opts.pluginName;
+  }
+};
+var AgentError = class extends WrongStackError {
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "agent",
+      severity: opts.code === ERROR_CODES.AGENT_ABORTED ? "warning" : "error",
+      recoverable: opts.recoverable ?? opts.code === ERROR_CODES.AGENT_ITERATION_LIMIT,
+      context: opts.context,
+      cause: opts.cause
+    });
+    this.name = "AgentError";
+  }
+};
+function toWrongStackError(err, code = ERROR_CODES.AGENT_RUN_FAILED) {
+  if (WrongStackError.isWrongStackError(err)) return err;
+  const message = toErrorMessage(err);
+  return new AgentError({
+    message,
+    code: code === "UNKNOWN" ? ERROR_CODES.AGENT_RUN_FAILED : code,
+    cause: err
+  });
+}
+var SessionError = class extends WrongStackError {
+  sessionId;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "session",
+      severity: opts.code === ERROR_CODES.SESSION_WRITE_FAILED ? "error" : "warning",
+      recoverable: opts.code !== ERROR_CODES.SESSION_CORRUPTED,
+      context: { sessionId: opts.sessionId, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "SessionError";
+    this.sessionId = opts.sessionId;
+  }
+};
+var SddError = class extends WrongStackError {
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "sdd",
+      severity: opts.code === ERROR_CODES.SDD_PARSE_FAILED ? "warning" : "error",
+      recoverable: opts.code === ERROR_CODES.SDD_NOT_READY,
+      context: opts.context,
+      cause: opts.cause
+    });
+    this.name = "SddError";
+  }
+};
+var FsError = class extends WrongStackError {
+  path;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "fs",
+      severity: "error",
+      recoverable: opts.code !== ERROR_CODES.FS_READ_FAILED,
+      context: { path: opts.path, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "FsError";
+    this.path = opts.path;
+  }
+};
+var FetchError = class extends WrongStackError {
+  status;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: ERROR_CODES.VALIDATION_ERROR,
+      subsystem: "general",
+      severity: "error",
+      recoverable: opts.status === 429 || opts.status >= 500,
+      context: { status: opts.status, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "FetchError";
+    this.status = opts.status;
+  }
+};
+var ToolValidationError = class extends WrongStackError {
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: ERROR_CODES.VALIDATION_ERROR,
+      subsystem: "general",
+      severity: "error",
+      recoverable: false,
+      context: { field: opts.field, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "ToolValidationError";
+  }
+};
+var ParseError = class extends WrongStackError {
+  source;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: ERROR_CODES.PARSE_FAILED,
+      subsystem: "general",
+      severity: "error",
+      recoverable: false,
+      context: { source: opts.source, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "ParseError";
+    this.source = opts.source;
+  }
+};
+function isWrongStackError(err) {
+  return err instanceof WrongStackError;
+}
+function isToolError(err) {
+  return err instanceof ToolError;
+}
+function isConfigError(err) {
+  return err instanceof ConfigError;
+}
+function isPluginError(err) {
+  return err instanceof PluginError;
+}
+function isSessionError(err) {
+  return err instanceof SessionError;
+}
+function isAgentError(err) {
+  return err instanceof AgentError;
+}
+function isFsError(err) {
+  return err instanceof FsError;
+}
+function isToolValidationError(err) {
+  return err instanceof ToolValidationError;
+}
+function isFetchError(err) {
+  return err instanceof FetchError;
+}
+function isParseError(err) {
+  return err instanceof ParseError;
+}
+function isSddError(err) {
+  return err instanceof SddError;
+}
+
+export {
+  ERROR_CODES,
+  WrongStackError,
+  ToolError,
+  ConfigError,
+  PluginError,
+  AgentError,
+  toWrongStackError,
+  SessionError,
+  SddError,
+  FsError,
+  FetchError,
+  ToolValidationError,
+  ParseError,
+  isWrongStackError,
+  isToolError,
+  isConfigError,
+  isPluginError,
+  isSessionError,
+  isAgentError,
+  isFsError,
+  isToolValidationError,
+  isFetchError,
+  isParseError,
+  isSddError
+};
+//# sourceMappingURL=chunk-WOEZV3Q4.js.map