open-agents-ai 0.187.526 → 0.187.527

package/dist/index.js

@@ -4842,10 +4842,10 @@ Try broader terms or use memory_read with a specific topic.`,
                 const data = JSON.parse(raw);
                 const topic = basename(file, ".json");
                 for (const [key, entry] of Object.entries(data)) {
-                  const dedup = `${topic}:${key}`;
-                  if (seen.has(dedup))
+                  const dedup2 = `${topic}:${key}`;
+                  if (seen.has(dedup2))
                     continue;
-                  seen.add(dedup);
+                  seen.add(dedup2);
                   if (entry?.value) {
                     entries.push({
                       topic,
@@ -524388,6 +524388,174 @@ var init_streaming_executor = __esm({
   }
 });
 
+// packages/orchestrator/dist/specDecomposer.js
+function isSourceModule(path8) {
+  if (!path8 || path8.includes(".."))
+    return false;
+  const cleaned = path8.trim().replace(/[`"',]+$/, "").replace(/\s+#.*$/, "");
+  if (!cleaned)
+    return false;
+  const dot = cleaned.lastIndexOf(".");
+  if (dot < 0)
+    return false;
+  const ext = cleaned.slice(dot).toLowerCase();
+  if (!SOURCE_EXTENSIONS.has(ext))
+    return false;
+  for (const re of EXCLUDE_PATTERNS) {
+    if (re.test(cleaned))
+      return false;
+  }
+  return true;
+}
+function extractFromTree(text) {
+  const lineRe = /^([ \t│]*)([├└])──\s+(\S+)/gm;
+  const out = [];
+  const parents = [];
+  let m2;
+  while ((m2 = lineRe.exec(text)) !== null) {
+    const prefix = m2[1];
+    const token = m2[3].replace(/\/+$/, "");
+    const depth = Math.floor(prefix.length / 4);
+    parents.length = depth;
+    const originalEndedWithSlash = m2[3].endsWith("/");
+    const hasExtension = token.includes(".") && !token.endsWith(".");
+    const isDir2 = originalEndedWithSlash || !hasExtension;
+    if (isDir2) {
+      parents[depth] = token;
+      continue;
+    }
+    const segments = parents.filter((p2) => p2 && p2.length > 0);
+    const fullPath = segments.length > 0 ? segments.join("/") + "/" + token : token;
+    if (isSourceModule(fullPath)) {
+      out.push({ path: fullPath });
+    }
+  }
+  return out;
+}
+function extractFromModuleSections(text) {
+  const re = /^#{2,4}\s+(?:Module|File):\s*[`"']?([^\s`"'\n]+)/gm;
+  const out = [];
+  let m2;
+  while ((m2 = re.exec(text)) !== null) {
+    const raw = m2[1].replace(/\/+$/, "");
+    if (isSourceModule(raw)) {
+      out.push({ path: raw });
+    }
+  }
+  return out;
+}
+function extractFromHeaderList(text) {
+  const re = /^#{3,4}\s+(?:Module:\s+)?[`"']?(src\/[^\s`"'\n]+\.[A-Za-z0-9]+)[`"']?/gm;
+  const out = [];
+  let m2;
+  while ((m2 = re.exec(text)) !== null) {
+    const raw = m2[1].replace(/\/+$/, "");
+    if (isSourceModule(raw)) {
+      out.push({ path: raw });
+    }
+  }
+  return out;
+}
+function decomposeSpec(taskText) {
+  if (!taskText || typeof taskText !== "string") {
+    return { modules: [], strategy: "none" };
+  }
+  const tree2 = dedup(extractFromTree(taskText));
+  if (tree2.length >= 3)
+    return { modules: tree2, strategy: "tree" };
+  const modSections = dedup(extractFromModuleSections(taskText));
+  if (modSections.length >= 3)
+    return { modules: modSections, strategy: "module-sections" };
+  const headers = dedup(extractFromHeaderList(taskText));
+  if (headers.length >= 3)
+    return { modules: headers, strategy: "module-headers" };
+  return { modules: [], strategy: "none" };
+}
+function dedup(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const e2 of items) {
+    if (seen.has(e2.path))
+      continue;
+    seen.add(e2.path);
+    out.push(e2);
+  }
+  return out;
+}
+function buildDecompositionDirective(modules, strategy) {
+  const moduleList = modules.slice(0, 30).map((m2, i2) => `  ${i2 + 1}. ${m2.path}`).join("\n");
+  const more = modules.length > 30 ? `
+  ... +${modules.length - 30} more` : "";
+  return [
+    `[SPEC DECOMPOSED — ${modules.length} modules detected via ${strategy}]`,
+    ``,
+    `Your task spec contains a clear module structure. To stay within context budget on a multi-module implementation, complete each module via sub_agent rather than in main context.`,
+    ``,
+    `Detected modules:`,
+    moduleList,
+    more,
+    ``,
+    `Recommended workflow:`,
+    `  1. Call todo_write with one todo per module (the orchestrator pre-populated this for you).`,
+    `  2. For EACH module, mark its todo in_progress, then call:`,
+    `       sub_agent({ subagent_type: "general", prompt: "Implement <module-path> per spec",`,
+    `                   relevantFiles: [{path:"<module-path>", content:"<existing or empty>"}], ... })`,
+    `  3. When sub_agent returns, mark the todo completed.`,
+    `  4. After ALL module todos are done, run the project's build/tests in main context.`,
+    `  5. If build/tests pass: call task_complete. If they fail: dispatch fix-up sub_agents for the failing module(s).`,
+    ``,
+    `Why this matters: implementing N modules in one context burns token budget linearly with N. sub_agent gives each module its own context window so the main context stays small for orchestration + integration verification.`,
+    ``,
+    `If you genuinely cannot use sub_agent for a module (e.g. it's a 3-line config file), inline editing in main context is fine — but for substantive modules, delegate.`
+  ].filter(Boolean).join("\n");
+}
+function buildDecompositionTodos(modules) {
+  return modules.map((m2, i2) => ({
+    id: `decomp-mod-${i2 + 1}`,
+    content: `Implement ${m2.path} (use sub_agent for focused context)`,
+    status: "pending"
+  }));
+}
+var SOURCE_EXTENSIONS, EXCLUDE_PATTERNS;
+var init_specDecomposer = __esm({
+  "packages/orchestrator/dist/specDecomposer.js"() {
+    "use strict";
+    SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".ts",
+      ".tsx",
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      ".py",
+      ".pyi",
+      ".rs",
+      ".go",
+      ".java",
+      ".kt",
+      ".c",
+      ".cc",
+      ".cpp",
+      ".h",
+      ".hpp",
+      ".rb",
+      ".php",
+      ".swift",
+      ".scala",
+      ".clj",
+      ".lua"
+    ]);
+    EXCLUDE_PATTERNS = [
+      // Excluded directories — match anywhere in path (start-or-slash boundary).
+      /(^|\/)(node_modules|dist|build|out|target|\.git|\.next|coverage|__pycache__|venv|\.venv)\//,
+      // Test fixtures + samples — keep src/ tests but drop fixture/sample dirs.
+      /(^|\/)(fixtures|samples)\//,
+      // Package metadata / config — caller doesn't want decomposition for these.
+      /(^|\/)(package\.json|package-lock\.json|yarn\.lock|pnpm-lock\.yaml|tsconfig\.json|jest\.config\.[jt]s|vitest\.config\.[jt]s|\.eslintrc\.[a-z]+|Cargo\.toml|Cargo\.lock|go\.mod|go\.sum|pyproject\.toml|requirements\.txt|setup\.py|\.gitignore|\.npmignore|README\.md|LICENSE)$/
+    ];
+  }
+});
+
 // packages/orchestrator/dist/preflightSnapshot.js
 var preflightSnapshot_exports = {};
 __export(preflightSnapshot_exports, {
@@ -525432,7 +525600,7 @@ RECOVERY: cd to the directory containing '${file}', run a plain install with no
 });
 
 // packages/orchestrator/dist/agenticRunner.js
-import { existsSync as _fsExistsSync, readFileSync as _fsReadFileSync } from "node:fs";
+import { existsSync as _fsExistsSync, readFileSync as _fsReadFileSync, writeFileSync as _fsWriteFileSync, mkdirSync as _fsMkdirSync } from "node:fs";
 import { join as _pathJoin } from "node:path";
 import { homedir as _osHomedir } from "node:os";
 import { z as z15 } from "zod";
@@ -525665,6 +525833,7 @@ var init_agenticRunner = __esm({
     init_hooks();
     init_app_state();
     init_streaming_executor();
+    init_specDecomposer();
     TOOL_SUBSETS = {
       web: ["web_search", "web_fetch", "web_crawl"],
       code: ["file_patch", "file_explore", "batch_edit", "file_read", "file_write", "file_edit"],
@@ -528474,6 +528643,46 @@ TASK: ${task}` : task;
           { role: "system", content: systemPrompt },
           { role: "user", content: userContent }
         ];
+        if (process.env["OA_DISABLE_DECOMP1"] !== "1") {
+          try {
+            const _taskBodyForDecomp = typeof userContent === "string" ? userContent : "";
+            const _decomp = decomposeSpec(_taskBodyForDecomp);
+            if (_decomp.modules.length > 0) {
+              const _directive = buildDecompositionDirective(_decomp.modules, _decomp.strategy);
+              messages2.push({ role: "system", content: _directive });
+              const _todos = buildDecompositionTodos(_decomp.modules);
+              try {
+                const sid = process.env["OA_SESSION_ID"] || this._sessionId || "default";
+                const safe = sid.replace(/[^a-zA-Z0-9_.-]/g, "_");
+                const fp = _pathJoin(_osHomedir(), ".open-agents", "todos", `${safe}.json`);
+                const dir = _pathJoin(_osHomedir(), ".open-agents", "todos");
+                try {
+                  _fsMkdirSync(dir, { recursive: true });
+                } catch {
+                }
+                let _existing = [];
+                try {
+                  if (_fsExistsSync(fp)) {
+                    const _parsed = JSON.parse(_fsReadFileSync(fp, "utf-8"));
+                    if (Array.isArray(_parsed))
+                      _existing = _parsed;
+                  }
+                } catch {
+                }
+                if (_existing.length === 0) {
+                  _fsWriteFileSync(fp, JSON.stringify(_todos, null, 2), "utf-8");
+                }
+              } catch {
+              }
+              this.emit({
+                type: "status",
+                content: `DECOMP-1 SPEC DECOMPOSED — ${_decomp.modules.length} modules detected via ${_decomp.strategy}; directive injected + todos pre-populated`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+          } catch {
+          }
+        }
         try {
           if (this.options.subAgent)
             throw "skip-handoff-subagent";
@@ -530379,7 +530588,18 @@ ${memoryLines.join("\n")}`
                 // agents used to ignore REG-61.
                 "web_search",
                 "task_complete",
-                "ask_user"
+                "ask_user",
+                // DECOMP-1: sub-agent dispatch is productive work (it spawns
+                // a focused-context implementation worker). Block-listing
+                // sub_agent here would defeat the spec-decomposition pattern
+                // — agents would be forced into main-context edits even when
+                // delegation is the right move. sub_agent calls do NOT clear
+                // the gate (we want the agent to also produce direct edits
+                // for orchestration glue / integration), but they're allowed
+                // through.
+                "sub_agent",
+                "priority_delegate",
+                "background_run"
               ]);
               if (REG61_EDIT_TOOLS.has(tc.name) && this._reg61PerpetualGateActive) {
                 this._reg61PerpetualGateActive = false;

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.526",
+  "version": "0.187.527",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.526",
+      "version": "0.187.527",
       "hasInstallScript": true,
       "license": "CC-BY-NC-4.0",
       "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.526",
+  "version": "0.187.527",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",