@wrongstack/core 0.310.1 → 0.313.1

package/dist/chunk-2BUUIMQB.js

@@ -0,0 +1,225 @@
+import {
+  AGENTS_BY_PHASE,
+  AGENT_CATALOG
+} from "./chunk-FHAMQS7Q.js";
+import {
+  fallbackProfileChain
+} from "./chunk-H72H4XDU.js";
+import {
+  parseModelRef
+} from "./chunk-RJIZEJ42.js";
+
+// src/coordination/model-matrix.ts
+var MATRIX_PHASE_KEYS = Object.keys(AGENTS_BY_PHASE);
+var ROLE_TO_PHASE = (() => {
+  const map = {};
+  for (const [phase, defs] of Object.entries(AGENTS_BY_PHASE)) {
+    for (const def of defs) {
+      const role = def.config.role;
+      if (role) map[role] = phase;
+    }
+  }
+  return map;
+})();
+function phaseForRole(role) {
+  return role ? ROLE_TO_PHASE[role] : void 0;
+}
+function resolveModelMatrixResolution(matrix, role) {
+  if (!matrix) return void 0;
+  if (role && matrix[role]) return { entry: matrix[role], source: "role", key: role };
+  const phase = phaseForRole(role);
+  if (phase && matrix[phase]) return { entry: matrix[phase], source: "phase", key: phase };
+  if (matrix["*"]) return { entry: matrix["*"], source: "default", key: "*" };
+  return void 0;
+}
+function resolveModelMatrix(matrix, role) {
+  return resolveModelMatrixResolution(matrix, role)?.entry;
+}
+function resolveModelTargetFromEntry(config, entry) {
+  if (!entry) return void 0;
+  if (entry.model) {
+    return {
+      provider: entry.provider,
+      model: entry.model,
+      modelRuntime: entry.modelRuntime,
+      fallbackProfile: entry.fallbackProfile,
+      fallbackModels: fallbackProfileChain(config, entry.fallbackProfile)
+    };
+  }
+  const chain = fallbackProfileChain(config, entry.fallbackProfile);
+  const first = chain[0];
+  if (!first) {
+    return entry.modelRuntime ? { modelRuntime: entry.modelRuntime } : void 0;
+  }
+  const parsed = parseModelRef(first);
+  return {
+    provider: parsed.provider,
+    model: parsed.model,
+    modelRuntime: entry.modelRuntime,
+    fallbackProfile: entry.fallbackProfile,
+    fallbackModels: chain.slice(1)
+  };
+}
+function roleNeedsIndependentReviewModel(role) {
+  if (!role) return false;
+  return role === "reviewer" || phaseForRole(role) === "review";
+}
+function resolveSubagentModelTarget(config, role, opts = {}) {
+  const resolution = resolveModelMatrixResolution(config.modelMatrix, role);
+  const matrixTarget = resolveModelTargetFromEntry(config, resolution?.entry);
+  const implementationTarget = opts.implementationTarget ?? resolveImplementationModelTarget(config);
+  const isAvailable = (providerId, model) => {
+    if (!opts.statusTracker) return true;
+    if (!providerId || !model) return true;
+    return opts.statusTracker.isAvailable(providerId, model);
+  };
+  const matrixEffective = materializeTarget(config, matrixTarget);
+  const matrixIsAvailable = !matrixEffective || isAvailable(matrixEffective.provider, matrixEffective.model);
+  if (!roleNeedsIndependentReviewModel(role)) {
+    if (!matrixTarget) return void 0;
+    if (!matrixIsAvailable) return void 0;
+    return {
+      ...matrixTarget,
+      source: "matrix",
+      matrixSource: resolution?.source
+    };
+  }
+  const matrixRef = materializeTarget(config, matrixTarget);
+  if (resolution?.source === "role" || resolution?.source === "phase") {
+    if (!matrixTarget) return void 0;
+    if (!matrixIsAvailable) return void 0;
+    return {
+      ...matrixTarget,
+      source: "matrix",
+      matrixSource: resolution.source
+    };
+  }
+  if (matrixRef && !sameModelReference(matrixRef, implementationTarget)) {
+    if (!matrixIsAvailable) return void 0;
+    return {
+      ...matrixTarget ?? {},
+      source: "matrix",
+      matrixSource: resolution?.source
+    };
+  }
+  const diverse = chooseDiverseModelTargetWithTracker(
+    config,
+    implementationTarget,
+    opts.statusTracker
+  );
+  if (diverse) {
+    return {
+      provider: diverse.provider,
+      model: diverse.model,
+      modelRuntime: matrixTarget?.modelRuntime,
+      fallbackModels: matrixTarget?.fallbackModels,
+      fallbackProfile: matrixTarget?.fallbackProfile,
+      source: "diversity",
+      matrixSource: resolution?.source,
+      diversified: true
+    };
+  }
+  if (!matrixTarget) return void 0;
+  if (!matrixIsAvailable) return void 0;
+  return {
+    ...matrixTarget,
+    source: "matrix",
+    matrixSource: resolution?.source
+  };
+}
+function resolveImplementationModelTarget(config) {
+  const target = resolveModelTargetFromEntry(
+    config,
+    resolveModelMatrix(config.modelMatrix, "executor")
+  );
+  return materializeTarget(config, target) ?? {
+    provider: config.provider,
+    model: config.model
+  };
+}
+function sameModelReference(a, b) {
+  if (!a?.model || !b?.model) return false;
+  const providerA = a.provider ?? "";
+  const providerB = b.provider ?? "";
+  return providerA === providerB && a.model === b.model;
+}
+function materializeTarget(config, target) {
+  if (!target?.model) return void 0;
+  return {
+    provider: target.provider ?? config.provider,
+    model: target.model
+  };
+}
+function chooseDiverseModelTarget(config, avoid) {
+  const candidates = collectConfiguredModelTargets(config).filter(
+    (candidate) => !sameModelReference(candidate, avoid)
+  );
+  candidates.sort((a, b) => modelDiversityScore(b, avoid) - modelDiversityScore(a, avoid));
+  return candidates[0];
+}
+function chooseDiverseModelTargetWithTracker(config, avoid, tracker) {
+  if (!tracker) return chooseDiverseModelTarget(config, avoid);
+  const ranked = collectConfiguredModelTargets(config).filter((candidate) => !sameModelReference(candidate, avoid)).sort((a, b) => modelDiversityScore(b, avoid) - modelDiversityScore(a, avoid));
+  for (const candidate of ranked) {
+    if (tracker.isAvailable(candidate.provider, candidate.model)) return candidate;
+  }
+  return void 0;
+}
+function collectConfiguredModelTargets(config) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const add = (provider, model) => {
+    if (!provider || !model) return;
+    const key = `${provider}\0${model}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push({ provider, model });
+  };
+  add(config.provider, config.model);
+  for (const [providerId, provider] of Object.entries(config.providers ?? {})) {
+    if (!isProviderAvailable(providerId, provider, config.provider)) continue;
+    for (const model of provider.models ?? []) add(providerId, model);
+    for (const model of Object.keys(provider.customModels ?? {})) add(providerId, model);
+  }
+  for (const model of Object.keys(config.models ?? {})) add(config.provider, model);
+  return out;
+}
+function isProviderAvailable(providerId, provider, leaderProvider) {
+  if (providerId === leaderProvider) return true;
+  if (typeof provider.apiKey === "string" && provider.apiKey.length > 0) return true;
+  if (Array.isArray(provider.apiKeys) && provider.apiKeys.some((key) => key?.apiKey)) return true;
+  if (typeof provider.baseUrl === "string" && provider.baseUrl.length > 0) return true;
+  return false;
+}
+function modelDiversityScore(candidate, avoid) {
+  let score = 0;
+  if (candidate.provider !== avoid.provider) score += 100;
+  if (candidate.model !== avoid.model) score += 20;
+  if (/opus|gpt-5|o3|o4|gemini.*pro|deepseek-r1/i.test(candidate.model)) score += 10;
+  if (/mini|haiku|flash/i.test(candidate.model)) score -= 5;
+  return score;
+}
+function matrixKeyKind(key) {
+  if (key === "*") return "default";
+  if (key in AGENT_CATALOG) return "role";
+  if (MATRIX_PHASE_KEYS.includes(key)) return "phase";
+  return "unknown";
+}
+function isValidMatrixKey(key) {
+  return matrixKeyKind(key) !== "unknown";
+}
+
+export {
+  MATRIX_PHASE_KEYS,
+  phaseForRole,
+  resolveModelMatrixResolution,
+  resolveModelMatrix,
+  resolveModelTargetFromEntry,
+  roleNeedsIndependentReviewModel,
+  resolveSubagentModelTarget,
+  resolveImplementationModelTarget,
+  sameModelReference,
+  matrixKeyKind,
+  isValidMatrixKey
+};
+//# sourceMappingURL=chunk-2BUUIMQB.js.map

package/dist/chunk-2FK4WTFF.js

@@ -0,0 +1,207 @@
+// src/types/mode-prompts.ts
+import { readFileSync, statSync } from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+function modePrompt(id) {
+  for (const dir of modePromptDirCandidates()) {
+    try {
+      return readFileSync(path.join(dir, `${id}.md`), "utf8").trimEnd();
+    } catch {
+    }
+  }
+  return "";
+}
+function modePromptDirCandidates() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path.resolve(here, "../../instructions/modes"),
+    path.resolve(here, "../instructions/modes"),
+    path.resolve(here, "instructions/modes")
+  ];
+  return candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
+}
+function isDirectory(candidate) {
+  try {
+    return statSync(candidate).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/types/mode.ts
+var DEFAULT_MODES = [
+  {
+    id: "default",
+    name: "Default",
+    description: "Balanced general-purpose mode; use when no special token/coverage trade-off is needed",
+    prompt: "",
+    tags: ["general", "balanced"]
+  },
+  {
+    id: "brief",
+    name: "Brief",
+    description: "Ultra-compact responses for low-context, high-speed work",
+    prompt: modePrompt("brief"),
+    tags: ["lite", "fast", "concise", "token-saving"],
+    toolPreferences: ["read", "edit", "bash"],
+    suggestedSkills: []
+  },
+  {
+    id: "review-lite",
+    name: "Review Lite",
+    description: "Token-saving code review: changed files only, top correctness/security risks",
+    prompt: modePrompt("review-lite"),
+    tags: ["lite", "review", "quality", "token-saving"],
+    toolPreferences: ["git", "diff", "read", "grep"],
+    suggestedSkills: ["bug-hunter", "typescript-strict"]
+  },
+  {
+    id: "audit-lite",
+    name: "Audit Lite",
+    description: "Token-saving security triage for a small diff or named file",
+    prompt: modePrompt("audit-lite"),
+    tags: ["lite", "security", "audit", "token-saving"],
+    toolPreferences: ["grep", "read", "git"],
+    suggestedSkills: ["security-scanner"]
+  },
+  {
+    id: "plan-lite",
+    name: "Plan Lite",
+    description: "Token-saving planning: 3-6 actionable steps, minimal design debate",
+    prompt: modePrompt("plan-lite"),
+    tags: ["lite", "planning", "architecture", "token-saving"],
+    toolPreferences: ["tree", "glob", "read", "grep"],
+    suggestedSkills: ["refactor-planner"]
+  },
+  {
+    id: "debug-lite",
+    name: "Debug Lite",
+    description: "Token-saving bug triage: one hypothesis, nearest evidence, narrow check",
+    prompt: modePrompt("debug-lite"),
+    tags: ["lite", "debug", "triage", "token-saving"],
+    toolPreferences: ["read", "grep", "test", "logs"],
+    suggestedSkills: ["bug-hunter"]
+  },
+  {
+    id: "test-lite",
+    name: "Test Lite",
+    description: "Token-saving tests: one focused regression or narrow verification target",
+    prompt: modePrompt("test-lite"),
+    tags: ["lite", "testing", "qa", "token-saving"],
+    toolPreferences: ["test", "read", "grep"],
+    suggestedSkills: ["testing"]
+  },
+  {
+    id: "refactor-lite",
+    name: "Refactor Lite",
+    description: "Token-saving cleanup: small scoped behavior-preserving changes",
+    prompt: modePrompt("refactor-lite"),
+    tags: ["lite", "refactor", "token-saving"],
+    toolPreferences: ["read", "edit", "test"],
+    suggestedSkills: ["typescript-strict"]
+  },
+  {
+    id: "research-lite",
+    name: "Research Lite",
+    description: "Token-saving web research: one search, one authoritative fetch, short answer",
+    prompt: modePrompt("research-lite"),
+    tags: ["lite", "research", "web", "token-saving"],
+    toolPreferences: ["search", "fetch"],
+    suggestedSkills: ["research-web"]
+  },
+  {
+    id: "code-reviewer",
+    name: "Review Deep",
+    description: "Comprehensive code review across contracts, edge cases, lifecycle, errors, concurrency",
+    prompt: modePrompt("code-reviewer"),
+    tags: ["deep", "review", "quality", "security"],
+    toolPreferences: ["read", "grep", "git", "diff", "test"],
+    suggestedSkills: ["bug-hunter", "security-scanner", "typescript-strict", "testing"]
+  },
+  {
+    id: "code-auditor",
+    name: "Audit Deep",
+    description: "Comprehensive security audit with category coverage and exploitability notes",
+    prompt: modePrompt("code-auditor"),
+    tags: ["deep", "security", "audit", "compliance"],
+    toolPreferences: ["grep", "read", "audit", "bash"],
+    suggestedSkills: ["security-scanner", "bug-hunter", "audit-log"]
+  },
+  {
+    id: "architect",
+    name: "Architecture Deep",
+    description: "Comprehensive architecture and cross-module contract analysis",
+    prompt: modePrompt("architect"),
+    tags: ["deep", "architecture", "design", "scalability"],
+    toolPreferences: ["read", "glob", "tree", "diff"],
+    suggestedSkills: ["api-design", "refactor-planner", "node-modern", "docker-deploy"]
+  },
+  {
+    id: "debugger",
+    name: "Debug Deep",
+    description: "Comprehensive root-cause analysis with traces, logs, assumptions, and verification",
+    prompt: modePrompt("debugger"),
+    tags: ["deep", "debug", "investigation", "error-resolution"],
+    toolPreferences: ["read", "grep", "bash", "logs", "test"],
+    suggestedSkills: ["bug-hunter", "audit-log", "observability"]
+  },
+  {
+    id: "tester",
+    name: "Test Deep",
+    description: "Comprehensive QA mode for coverage, boundaries, isolation, and integration gaps",
+    prompt: modePrompt("tester"),
+    tags: ["deep", "testing", "qa", "quality"],
+    toolPreferences: ["read", "grep", "test", "bash"],
+    suggestedSkills: ["testing", "bug-hunter", "typescript-strict"]
+  },
+  {
+    id: "devops",
+    name: "DevOps Deep",
+    description: "Comprehensive infrastructure, deployment, observability, and operations review",
+    prompt: modePrompt("devops"),
+    tags: ["deep", "devops", "infrastructure", "operations"],
+    toolPreferences: ["read", "bash", "grep", "logs", "git"],
+    suggestedSkills: ["docker-deploy", "observability", "security-scanner"]
+  },
+  {
+    id: "refactorer",
+    name: "Refactor Deep",
+    description: "Comprehensive modernization/refactor mode with contracts and verification discipline",
+    prompt: modePrompt("refactorer"),
+    tags: ["deep", "refactor", "modernization", "improvement"],
+    toolPreferences: ["read", "edit", "test", "git", "grep"],
+    suggestedSkills: ["refactor-planner", "typescript-strict", "node-modern", "testing"]
+  },
+  {
+    id: "ui-design",
+    name: "UI Design Deep",
+    description: "Comprehensive design-first frontend/mobile UI work with kit, tokens, and accessibility",
+    prompt: modePrompt("ui-design"),
+    tags: ["deep", "ui", "frontend", "mobile", "design"],
+    toolPreferences: ["design", "write", "edit", "read", "scaffold"],
+    suggestedSkills: ["react-modern"]
+  },
+  {
+    id: "teach",
+    name: "Teach Deep",
+    description: "Mentor mode with explanations, mental models, trade-offs, and takeaways",
+    prompt: modePrompt("teach"),
+    tags: ["deep", "teaching", "mentor", "learning"],
+    toolPreferences: ["read", "edit", "explain"],
+    suggestedSkills: ["prompt-engineering", "skill-creator", "node-modern", "typescript-strict"]
+  },
+  {
+    id: "research-web",
+    name: "Research Deep",
+    description: "Comprehensive current-data research with cross-checking and reusable findings",
+    prompt: modePrompt("research-web"),
+    tags: ["deep", "research", "web", "current-data", "up-to-date"],
+    toolPreferences: ["search", "fetch", "context_manager"],
+    suggestedSkills: ["research-web", "tech-stack", "node-modern", "security-scanner", "react-modern"]
+  }
+];
+
+export {
+  DEFAULT_MODES
+};
+//# sourceMappingURL=chunk-2FK4WTFF.js.map