opencode-ultra 0.7.7 → 0.8.0

package/dist/index.js

@@ -28603,6 +28603,72 @@ function formatResult(result) {
 }
 
 // src/tools/evolve-filter.ts
+var EvolveProposalSchema = exports_external.object({
+  title: exports_external.string().min(1),
+  priority: exports_external.enum(["P0", "P1", "P2"]),
+  effort: exports_external.enum(["Low", "Medium", "High"]),
+  description: exports_external.string().optional(),
+  files: exports_external.array(exports_external.string()).optional(),
+  currentState: exports_external.string().optional(),
+  inspiration: exports_external.string().optional(),
+  current_state: exports_external.string().optional(),
+  why: exports_external.string().optional(),
+  how: exports_external.string().optional()
+}).transform((v) => {
+  const legacyDesc = [v.why, v.how].filter((s) => typeof s === "string" && s.length > 0);
+  return {
+    title: v.title,
+    priority: v.priority,
+    effort: v.effort,
+    description: v.description ?? (legacyDesc.length > 0 ? legacyDesc.join(`
+`) : ""),
+    files: v.files,
+    currentState: v.currentState ?? v.current_state,
+    inspiration: v.inspiration
+  };
+});
+function validateProposalJsonl(line) {
+  const raw = line.trim();
+  if (!raw)
+    return { ok: false, error: "Empty line" };
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: `Invalid JSON: ${msg}` };
+  }
+  const result = EvolveProposalSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => {
+      const path8 = i.path.length > 0 ? i.path.join(".") : "(root)";
+      return `${path8}: ${i.message}`;
+    }).join("; ");
+    return { ok: false, error: `Schema validation failed: ${issues}` };
+  }
+  return { ok: true, proposal: result.data };
+}
+function normalizeTitleForDedup(title) {
+  return title.normalize("NFKC").toLowerCase().replace(/[\p{P}\p{S}\s]+/gu, "").trim();
+}
+function deduplicateProposals(existing, incoming) {
+  const seen = new Set;
+  const out = [];
+  const add = (p) => {
+    const key = normalizeTitleForDedup(p.title);
+    if (key.length === 0)
+      return;
+    if (seen.has(key))
+      return;
+    seen.add(key);
+    out.push(p);
+  };
+  for (const p of existing)
+    add(p);
+  for (const p of incoming)
+    add(p);
+  return out;
+}
 var PRIORITY_WEIGHT = {
   P0: 10,
   P1: 5,
@@ -28756,6 +28822,186 @@ evolve_score({ markdown: "## Improvement: Rate Limiting\\n**Priority**: P0\\n**E
   });
 }
 
+// src/tools/evolve-scan.ts
+import * as fs8 from "fs";
+import * as path8 from "path";
+function splitJsonl(text) {
+  return text.split(/\r?\n/);
+}
+function parseJsonl(text) {
+  const proposals = [];
+  const errors5 = [];
+  const lines = splitJsonl(text);
+  for (let i = 0;i < lines.length; i++) {
+    const raw = lines[i] ?? "";
+    if (!raw.trim())
+      continue;
+    const v = validateProposalJsonl(raw);
+    if (v.ok === false) {
+      errors5.push({ line: i + 1, raw, error: v.error });
+      continue;
+    }
+    proposals.push(v.proposal);
+  }
+  return { proposals, errors: errors5 };
+}
+function proposalToJson(p) {
+  const out = {
+    title: p.title,
+    priority: p.priority,
+    effort: p.effort,
+    description: p.description
+  };
+  if (p.files && p.files.length > 0)
+    out.files = p.files;
+  if (p.currentState)
+    out.currentState = p.currentState;
+  if (p.inspiration)
+    out.inspiration = p.inspiration;
+  return out;
+}
+function formatMaybeCode(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+function markdownEscape(s) {
+  return s.replaceAll("|", "\\|").replaceAll(`
+`, " ");
+}
+function buildReport(args) {
+  const lines = [];
+  lines.push("# Evolve Scan Report");
+  lines.push("");
+  lines.push("## Metadata");
+  lines.push(`- Generated: ${args.generatedAt}`);
+  lines.push(`- Search query: ${args.query && args.query.trim() ? args.query.trim() : "(not provided)"}`);
+  lines.push(`- Threshold: minScore=${args.minScore}, maxProposals=${args.maxProposals}`);
+  lines.push(`- Proposals: existing=${args.existingCount}, incoming=${args.incomingCount}, merged=${args.mergedCount}, accepted=${args.acceptedCount}, rejected=${args.rejectedCount}`);
+  lines.push(`- Invalid JSONL lines skipped: ${args.existingErrors.length + args.incomingErrors.length}`);
+  lines.push("");
+  lines.push("## Feature Matrix");
+  lines.push("");
+  if (args.featureMatrix && args.featureMatrix.trim()) {
+    lines.push(args.featureMatrix.trim());
+  } else {
+    lines.push("_(not provided)_");
+  }
+  lines.push("");
+  lines.push("## Scored Proposals");
+  lines.push("");
+  lines.push(`### Accepted (${args.accepted.length})`);
+  lines.push("");
+  if (args.accepted.length === 0) {
+    lines.push("_(none)_");
+  } else {
+    lines.push("| Title | Score | Priority | Effort | Description | Inspiration | Current state |");
+    lines.push("|---|---:|---|---|---|---|---|");
+    for (const p of args.accepted) {
+      lines.push(`| ${markdownEscape(p.title)} | ${p.score} | ${p.priority} | ${p.effort} | ${markdownEscape(formatMaybeCode(p.description))} | ${markdownEscape(p.inspiration ? formatMaybeCode(p.inspiration) : "")} | ${markdownEscape(p.currentState ? formatMaybeCode(p.currentState) : "")} |`);
+    }
+  }
+  lines.push("");
+  lines.push(`### Rejected (${args.rejected.length})`);
+  lines.push("");
+  if (args.rejected.length === 0) {
+    lines.push("_(none)_");
+  } else {
+    lines.push("| Title | Score | Priority | Effort | Reason |");
+    lines.push("|---|---:|---|---|---|");
+    for (const p of args.rejected) {
+      lines.push(`| ${markdownEscape(p.title)} | ${p.score} | ${p.priority} | ${p.effort} | ${markdownEscape(p.reason ? formatMaybeCode(p.reason) : "")} |`);
+    }
+  }
+  lines.push("");
+  const allErrors = [
+    ...args.existingErrors.map((e) => ({ ...e, source: "existing" })),
+    ...args.incomingErrors.map((e) => ({ ...e, source: "incoming" }))
+  ];
+  if (allErrors.length > 0) {
+    lines.push("## Skipped JSONL Lines");
+    lines.push("");
+    for (const e of allErrors) {
+      lines.push(`- ${e.source} line ${e.line}: ${e.error}`);
+    }
+    lines.push("");
+  }
+  lines.push("## Score Reference");
+  lines.push("");
+  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");
+  lines.push("");
+  return lines.join(`
+`);
+}
+function createEvolveScanTool() {
+  return tool({
+    description: `Scan/validate evolve proposals JSONL, merge with existing proposals, score them, and generate a report.
+
+Writes outputs to:
+- .opencode/evolve-proposals.jsonl (validated, deduplicated)
+- .opencode/evolve-report.md (Feature Matrix + Scored Proposals + metadata)
+
+This tool only writes into .opencode/ and does not modify source code.`,
+    args: {
+      proposalsJsonl: tool.schema.string().optional().describe("Incoming proposals as raw JSONL text (optional; merged into existing file)"),
+      featureMatrix: tool.schema.string().optional().describe("Feature matrix markdown (Phase 2 output) to embed into the report"),
+      query: tool.schema.string().optional().describe("Search query used during research (for report metadata)"),
+      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 generatedAt = new Date().toISOString();
+      const minScore = args.minScore ?? 5;
+      const maxProposals = args.maxProposals ?? 3;
+      const outDir = path8.join(process.cwd(), ".opencode");
+      const proposalsPath = path8.join(outDir, "evolve-proposals.jsonl");
+      const reportPath = path8.join(outDir, "evolve-report.md");
+      fs8.mkdirSync(outDir, { recursive: true });
+      const existingText = fs8.existsSync(proposalsPath) ? fs8.readFileSync(proposalsPath, "utf-8") : "";
+      const existingParsed = existingText ? parseJsonl(existingText) : { proposals: [], errors: [] };
+      const incomingParsed = args.proposalsJsonl ? parseJsonl(args.proposalsJsonl) : { proposals: [], errors: [] };
+      const existingDeduped = deduplicateProposals([], existingParsed.proposals);
+      const merged = deduplicateProposals(existingDeduped, incomingParsed.proposals);
+      const addedCount = merged.length - existingDeduped.length;
+      const existingDupesRemoved = existingParsed.proposals.length - existingDeduped.length;
+      const incomingDupesSkipped = incomingParsed.proposals.length - addedCount;
+      const filtered = filterProposals(merged, { minScore, maxProposals });
+      const accepted = filtered.filter((p) => p.accepted).map((p) => ({ ...p, score: p.score }));
+      const rejected = filtered.filter((p) => !p.accepted).map((p) => ({ ...p, score: p.score, reason: p.reason }));
+      const jsonlOut = merged.map((p) => JSON.stringify(proposalToJson(p))).join(`
+`) + (merged.length > 0 ? `
+` : "");
+      fs8.writeFileSync(proposalsPath, jsonlOut, "utf-8");
+      const report = buildReport({
+        generatedAt,
+        query: args.query,
+        minScore,
+        maxProposals,
+        featureMatrix: args.featureMatrix,
+        existingCount: existingParsed.proposals.length,
+        incomingCount: incomingParsed.proposals.length,
+        mergedCount: merged.length,
+        acceptedCount: accepted.length,
+        rejectedCount: rejected.length,
+        existingErrors: existingParsed.errors,
+        incomingErrors: incomingParsed.errors,
+        accepted: accepted.map((p) => ({ ...p, score: scoreProposal(p) })),
+        rejected: rejected.map((p) => ({ ...p, score: scoreProposal(p) }))
+      });
+      fs8.writeFileSync(reportPath, report, "utf-8");
+      const skippedInvalid = existingParsed.errors.length + incomingParsed.errors.length;
+      return [
+        "## evolve_scan complete",
+        `- Wrote: ${proposalsPath}`,
+        `- Wrote: ${reportPath}`,
+        `- Existing proposals: ${existingParsed.proposals.length} (dedup removed ${existingDupesRemoved})`,
+        `- Incoming proposals: ${incomingParsed.proposals.length} (dedup skipped ${incomingDupesSkipped}, invalid skipped ${incomingParsed.errors.length})`,
+        `- Merged proposals: ${merged.length} (accepted ${accepted.length}, rejected ${rejected.length})`,
+        `- Invalid JSONL lines skipped (total): ${skippedInvalid}`
+      ].join(`
+`);
+    }
+  });
+}
+
 // src/hooks/todo-enforcer.ts
 var DEFAULT_MAX_ENFORCEMENTS = 5;
 var sessionState = new Map;
@@ -28838,7 +29084,7 @@ ${unfinished.map((t) => `- [ ] ${t.text}`).join(`
 }
 
 // src/hooks/comment-checker.ts
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 var AI_SLOP_PATTERNS = [
   /\/\/ .{80,}/,
   /\/\/ (This|The|We|Here|Note:)/i,
@@ -28917,7 +29163,7 @@ function createCommentCheckerHook(internalSessions, maxRatio = 0.3, slopThreshol
     if (!filePath || !isCodeFile(filePath))
       return;
     try {
-      const content = fs8.readFileSync(filePath, "utf-8");
+      const content = fs9.readFileSync(filePath, "utf-8");
       const result = checkComments(content, filePath, maxRatio, slopThreshold);
       if (result.shouldWarn) {
         output.output += `
@@ -29291,6 +29537,9 @@ var OpenCodeUltra = async (ctx) => {
   if (!disabledTools.has("evolve_apply")) {
     toolRegistry.evolve_apply = evolveApply;
   }
+  if (!disabledTools.has("evolve_scan")) {
+    toolRegistry.evolve_scan = createEvolveScanTool();
+  }
   if (!disabledTools.has("evolve_score")) {
     toolRegistry.evolve_score = createEvolveScoreTool();
   }

package/dist/tools/evolve-filter.d.ts

@@ -2,7 +2,10 @@
  * evolve-filter — Pure scoring and filtering logic for evolve proposals.
  *
  * No side effects. All functions are deterministic.
+ * Also exports createEvolveScoreTool() for LLM-facing tool registration.
  */
+import { tool } from "@opencode-ai/plugin";
+import { z } from "zod";
 export interface EvolveProposal {
     title: string;
     priority: "P0" | "P1" | "P2";
@@ -12,6 +15,32 @@ export interface EvolveProposal {
     currentState?: string;
     inspiration?: string;
 }
+/**
+ * JSONL schema for evolve proposals.
+ *
+ * Accepts both canonical keys (description/currentState) and legacy keys
+ * (why/how/current_state) used by older evolve prompts.
+ */
+export declare const EvolveProposalSchema: z.ZodType<EvolveProposal>;
+export type ProposalJsonlValidation = {
+    ok: true;
+    proposal: EvolveProposal;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Parse and validate a single JSONL line.
+ *
+ * Returns {ok:false,error} for invalid lines so callers can skip with reason.
+ */
+export declare function validateProposalJsonl(line: string): ProposalJsonlValidation;
+/**
+ * Merge existing + incoming proposals, skipping duplicates by normalized title.
+ *
+ * Normalization: lowercase + punctuation/symbol/whitespace removed.
+ */
+export declare function deduplicateProposals(existing: EvolveProposal[], incoming: EvolveProposal[]): EvolveProposal[];
 export interface FilteredProposal extends EvolveProposal {
     score: number;
     accepted: boolean;
@@ -38,3 +67,10 @@ export declare function filterProposals(proposals: EvolveProposal[], config?: Fi
  * ```
  */
 export declare function parseProposalsFromMarkdown(markdown: string): EvolveProposal[];
+/**
+ * Tool: evolve_score
+ *
+ * Takes evolve proposal markdown, parses it, scores each proposal,
+ * and returns a prioritized list. Pure computation, no agent spawning.
+ */
+export declare function createEvolveScoreTool(): ReturnType<typeof tool>;

package/dist/tools/evolve-scan.d.ts

@@ -0,0 +1,7 @@
+/**
+ * evolve_scan — validate + merge + score evolve proposals.
+ *
+ * This tool is scan/report oriented and only writes into `.opencode/`.
+ */
+import { tool } from "@opencode-ai/plugin";
+export declare function createEvolveScanTool(): ReturnType<typeof tool>;

package/package.json

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