opencode-ultra 0.7.2 → 0.7.4

package/dist/index.js

@@ -14541,7 +14541,7 @@ function detectConfigFile(basePath) {
   return null;
 }
 function loadConfig(projectDir) {
-  const userPath = detectConfigFile(path.join(getConfigDir(), "oh-my-opencode"));
+  const userPath = detectConfigFile(path.join(getConfigDir(), "opencode-ultra"));
   let config2 = {};
   if (userPath) {
     try {
@@ -14552,7 +14552,7 @@ function loadConfig(projectDir) {
       log(`Error loading user config: ${err}`);
     }
   }
-  const projectPath = detectConfigFile(path.join(projectDir, ".opencode", "oh-my-opencode"));
+  const projectPath = detectConfigFile(path.join(projectDir, ".opencode", "opencode-ultra"));
   if (projectPath) {
     try {
       const content = fs.readFileSync(projectPath, "utf-8");
@@ -28600,6 +28600,160 @@ function formatResult(result) {
 `);
 }
 
+// src/tools/evolve-filter.ts
+var PRIORITY_WEIGHT = {
+  P0: 10,
+  P1: 5,
+  P2: 1
+};
+var EFFORT_WEIGHT = {
+  Low: 3,
+  Medium: 2,
+  High: 1
+};
+var DEFAULT_MIN_SCORE = 5;
+var DEFAULT_MAX_PROPOSALS = 3;
+function scoreProposal(p) {
+  const pw = PRIORITY_WEIGHT[p.priority] ?? 1;
+  const ew = EFFORT_WEIGHT[p.effort] ?? 1;
+  return pw * ew;
+}
+function filterProposals(proposals, config3) {
+  const minScore = config3?.minScore ?? DEFAULT_MIN_SCORE;
+  const maxProposals = config3?.maxProposals ?? DEFAULT_MAX_PROPOSALS;
+  const scored = proposals.map((p) => {
+    const score = scoreProposal(p);
+    const accepted2 = score >= minScore;
+    return {
+      ...p,
+      score,
+      accepted: accepted2,
+      reason: accepted2 ? undefined : `Score ${score} below threshold ${minScore}`
+    };
+  });
+  const accepted = scored.filter((p) => p.accepted).sort((a, b) => b.score - a.score).slice(0, maxProposals);
+  const rejected = scored.filter((p) => !p.accepted);
+  const acceptedSet = new Set(accepted);
+  const overflow = scored.filter((p) => p.accepted && !acceptedSet.has(p)).map((p) => ({ ...p, accepted: false, reason: `Exceeded maxProposals (${maxProposals})` }));
+  return [...accepted, ...overflow, ...rejected];
+}
+function parseProposalsFromMarkdown(markdown) {
+  const proposals = [];
+  const sections = markdown.split(/^##\s+Improvement:\s*/m);
+  for (let i = 1;i < sections.length; i++) {
+    const section = sections[i];
+    const lines = section.trim();
+    const titleMatch = lines.match(/^(.+?)(?:\n|$)/);
+    const title = titleMatch?.[1]?.trim() ?? "Untitled";
+    const priority = extractField(lines, "Priority");
+    const effort = extractField(lines, "Effort");
+    const description = extractField(lines, "Why") || extractField(lines, "How") || "";
+    const currentState = extractField(lines, "Current state") || undefined;
+    const inspiration = extractField(lines, "Inspiration") || undefined;
+    const normalizedPriority = normalizePriority(priority);
+    const normalizedEffort = normalizeEffort(effort);
+    if (normalizedPriority && normalizedEffort) {
+      proposals.push({
+        title,
+        priority: normalizedPriority,
+        effort: normalizedEffort,
+        description,
+        currentState,
+        inspiration
+      });
+    }
+  }
+  return proposals;
+}
+function extractField(text, fieldName) {
+  const pattern = new RegExp(`\\*\\*${fieldName}\\*\\*\\s*:\\s*(.+?)(?:\\n|$)`, "i");
+  const match = text.match(pattern);
+  return match?.[1]?.trim() ?? "";
+}
+function normalizePriority(raw) {
+  const upper = raw.toUpperCase().trim();
+  if (upper.startsWith("P0"))
+    return "P0";
+  if (upper.startsWith("P1"))
+    return "P1";
+  if (upper.startsWith("P2"))
+    return "P2";
+  return null;
+}
+function normalizeEffort(raw) {
+  const lower = raw.toLowerCase().trim();
+  if (lower.startsWith("low"))
+    return "Low";
+  if (lower.startsWith("medium") || lower.startsWith("med"))
+    return "Medium";
+  if (lower.startsWith("high"))
+    return "High";
+  return null;
+}
+function createEvolveScoreTool() {
+  return tool({
+    description: `Score and rank evolve improvement proposals.
+
+Takes the markdown output from an evolve scan (Phase 3 proposals) and returns scored, filtered results.
+
+Scoring: priority_weight \xD7 effort_weight
+  P0=10, P1=5, P2=1 | Low=3, Medium=2, High=1
+  Best: P0+Low=30 | Worst: P2+High=1
+
+Input must contain proposals in this format:
+## Improvement: [Title]
+**Priority**: P0 / P1 / P2
+**Effort**: Low / Medium / High
+**Why**: [reason]
+
+Example:
+evolve_score({ markdown: "## Improvement: Rate Limiting\\n**Priority**: P0\\n**Effort**: Low\\n**Why**: Prevents API overload" })`,
+    args: {
+      markdown: tool.schema.string().describe("Markdown containing evolve proposals (## Improvement: format)"),
+      minScore: tool.schema.number().optional().describe("Minimum score to accept (default: 5)"),
+      maxProposals: tool.schema.number().optional().describe("Max proposals to accept (default: 3)")
+    },
+    execute: async (args) => {
+      const parsed = parseProposalsFromMarkdown(args.markdown);
+      if (parsed.length === 0) {
+        return `No proposals found. Ensure proposals use the format:
+## Improvement: [Title]
+**Priority**: P0/P1/P2
+**Effort**: Low/Medium/High`;
+      }
+      const filtered = filterProposals(parsed, {
+        minScore: args.minScore,
+        maxProposals: args.maxProposals
+      });
+      const accepted = filtered.filter((p) => p.accepted);
+      const rejected = filtered.filter((p) => !p.accepted);
+      const lines = [];
+      lines.push(`## Evolve Score Results (${parsed.length} parsed, ${accepted.length} accepted)`);
+      lines.push("");
+      if (accepted.length > 0) {
+        lines.push("### Accepted (by score descending)");
+        for (const p of accepted) {
+          lines.push(`- **${p.title}** \u2014 score=${p.score} [${p.priority}/${p.effort}]`);
+          if (p.description)
+            lines.push(`  ${p.description}`);
+        }
+        lines.push("");
+      }
+      if (rejected.length > 0) {
+        lines.push("### Rejected");
+        for (const p of rejected) {
+          lines.push(`- **${p.title}** \u2014 score=${p.score} [${p.priority}/${p.effort}] \u2014 ${p.reason}`);
+        }
+        lines.push("");
+      }
+      lines.push("### Score Reference");
+      lines.push("P0+Low=30 | P0+Med=20 | P0+High=10 | P1+Low=15 | P1+Med=10 | P1+High=5 | P2+Low=3 | P2+Med=2 | P2+High=1");
+      return lines.join(`
+`);
+    }
+  });
+}
+
 // src/hooks/todo-enforcer.ts
 var DEFAULT_MAX_ENFORCEMENTS = 5;
 var sessionState = new Map;
@@ -29135,6 +29289,9 @@ var OpenCodeUltra = async (ctx) => {
   if (!disabledTools.has("evolve_apply")) {
     toolRegistry.evolve_apply = evolveApply;
   }
+  if (!disabledTools.has("evolve_score")) {
+    toolRegistry.evolve_score = createEvolveScoreTool();
+  }
   return {
     tool: toolRegistry,
     config: async (config3) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ultra",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "Lightweight OpenCode 1.2.x plugin — ultrawork mode, multi-agent orchestration, rules injection",
   "keywords": [
     "opencode",