jules-orchestrator-kit 0.32.3 → 0.32.5

package/src/stack-detector.mjs

@@ -1,5 +1,5 @@
 import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync } from "node:fs";
-import { join, sep } from "node:path";
+import { join, relative } from "node:path";
 
 /**
  * Generate a zero-dependency smoke test file using node:test for untested JS/Generic repos.
@@ -155,6 +155,31 @@ export function detectPolyglotStack(projectRoot = process.cwd()) {
     return { ...container, stack: "make", testCmd: "make test", buildCmd: "make build", triggerFile: "Makefile" };
   }
 
+  // 4b. Web3 / Solidity / Foundry & Hardhat
+  if (existsSync(join(projectRoot, "foundry.toml")) || existsSync(join(projectRoot, "remappings.txt"))) {
+    const triggerFile = existsSync(join(projectRoot, "foundry.toml")) ? "foundry.toml" : "remappings.txt";
+    return {
+      ...container,
+      stack: "foundry",
+      testCmd: "forge test --offline",
+      buildCmd: "forge build --offline",
+      fmtCmd: "forge fmt --check",
+      fuzzCmd: "forge test --offline --match-test testFuzz",
+      invariantCmd: "forge test --offline --match-test invariant",
+      triggerFile,
+    };
+  }
+  if (existsSync(join(projectRoot, "hardhat.config.js")) || existsSync(join(projectRoot, "hardhat.config.ts"))) {
+    const triggerFile = existsSync(join(projectRoot, "hardhat.config.ts")) ? "hardhat.config.ts" : "hardhat.config.js";
+    return {
+      ...container,
+      stack: "hardhat",
+      testCmd: "npx hardhat test",
+      buildCmd: "npx hardhat compile",
+      triggerFile,
+    };
+  }
+
   // 5. Python / Django / Elixir / Ruby / Java
   if (existsSync(join(projectRoot, "manage.py"))) {
     return { ...container, stack: "django", testCmd: "python manage.py test --keepdb", buildCmd: "python manage.py check", triggerFile: "manage.py" };
@@ -230,42 +255,366 @@ export function detectPolyglotStack(projectRoot = process.cwd()) {
   return { ...container, stack: "unknown", testCmd: "", buildCmd: "", triggerFile: null };
 }
 
+/**
+ * Normalizes file paths to POSIX slashes.
+ */
+function toPosixPath(p = "") {
+  return p.replace(/\\/g, "/");
+}
+
+/**
+ * Finds the nearest subproject root directory for a given relative file path.
+ */
+export function findSubprojectRoot(fileRelPath = "", root = process.cwd()) {
+  const normalized = toPosixPath(fileRelPath);
+  const parts = normalized.split("/");
+  if (parts.length <= 1) return ".";
+
+  const manifestFiles = [
+    "package.json",
+    "foundry.toml",
+    "hardhat.config.js",
+    "hardhat.config.ts",
+    "Cargo.toml",
+    "go.mod",
+    "pyproject.toml",
+    "setup.py",
+    "requirements.txt",
+    "composer.json",
+    "pom.xml",
+    "build.gradle",
+  ];
+
+  // Walk up from parent directory of file to top-level folder
+  for (let i = parts.length - 1; i >= 1; i--) {
+    const candidateDir = parts.slice(0, i).join("/");
+    const fullCandidate = join(root, candidateDir);
+    if (existsSync(fullCandidate)) {
+      try {
+        const entries = readdirSync(fullCandidate);
+        const hasManifest = entries.some(
+          (e) => manifestFiles.includes(e) || e.endsWith(".csproj") || e.endsWith(".fsproj")
+        );
+        if (hasManifest) {
+          return candidateDir;
+        }
+      } catch (_) {}
+    }
+  }
+
+  return ".";
+}
+
+/**
+ * Detects illegal cross-package imports escaping subproject boundaries in monorepos.
+ */
+export function detectCrossPackageBoundaryViolations(changedFiles = [], root = process.cwd(), options = {}) {
+  const violations = [];
+  if (!changedFiles || changedFiles.length === 0) return violations;
+
+  const fileContents = options.fileContents || {};
+
+  // Regex patterns for relative imports across languages
+  const jsImportRegex = /(?:import\s+(?:[\w*\s{},]*\s+from\s+)?|export\s+(?:[\w*\s{},]*\s+from\s+)?|require\s*\(\s*|import\s*\(\s*)['"](\.[^'"]+)['"]/g;
+  const goImportRegex = /(?:^|\n)\s*(?:import\s+['"](\.[^'"]+)['"]|import\s*\([\s\S]*?['"](\.[^'"]+)['"][\s\S]*?\))/g;
+  const rustPathRegex = /#\[path\s*=\s*['"](\.[^'"]+)['"]\]/g;
+  const pyRelImportRegex = /(?:^|\n)\s*from\s+(\.{2,}\w*)\s+import/g;
+
+  for (const file of changedFiles) {
+    const posixFile = toPosixPath(file);
+    let content = fileContents[file] || fileContents[posixFile];
+
+    if (!content) {
+      const fullPath = join(root, file);
+      if (existsSync(fullPath)) {
+        try {
+          content = readFileSync(fullPath, "utf-8");
+        } catch (_) {}
+      }
+    }
+
+    if (!content || typeof content !== "string") continue;
+
+    const subproject = findSubprojectRoot(posixFile, root);
+    if (subproject === "." && !options.enforceRootBoundary) {
+      continue;
+    }
+
+    const fileDir = posixFile.includes("/") ? posixFile.substring(0, posixFile.lastIndexOf("/")) : ".";
+    const ext = posixFile.includes(".") ? posixFile.substring(posixFile.lastIndexOf(".")).toLowerCase() : "";
+    const isJsTs = [".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx", ".svelte", ".vue"].includes(ext) || !ext;
+    const isGo = ext === ".go";
+    const isRust = ext === ".rs";
+    const isPython = ext === ".py";
+
+    const lines = content.split("\n");
+
+    for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+      const line = lines[lineIdx];
+
+      // 1. JS / TS imports
+      if (isJsTs) {
+        let match;
+        jsImportRegex.lastIndex = 0;
+        while ((match = jsImportRegex.exec(line)) !== null) {
+          const relTarget = match[1];
+          if (relTarget.startsWith("..")) {
+            const resolved = toPosixPath(join(fileDir, relTarget));
+            const relToSubproject = toPosixPath(relative(subproject, resolved));
+            if (relToSubproject.startsWith("..") || resolved === "." || (subproject !== "." && !resolved.startsWith(subproject + "/"))) {
+              violations.push({
+                file: posixFile,
+                subproject,
+                importTarget: relTarget,
+                resolvedTarget: resolved,
+                line: lineIdx + 1,
+                language: "javascript/typescript",
+                reason: `Cross-Package Boundary Violation: File "${posixFile}" in package "${subproject}" illegally imports "${relTarget}" (resolves to "${resolved}"), escaping its package boundary. Declare a workspace dependency instead of a relative cross-package file import.`,
+              });
+            }
+          }
+        }
+      }
+
+      // 2. Go relative imports escaping module
+      if (isGo) {
+        let match;
+        goImportRegex.lastIndex = 0;
+        while ((match = goImportRegex.exec(line)) !== null) {
+          const relTarget = match[1] || match[2];
+          if (relTarget && relTarget.startsWith("..")) {
+            const resolved = toPosixPath(join(fileDir, relTarget));
+            const relToSubproject = toPosixPath(relative(subproject, resolved));
+            if (relToSubproject.startsWith("..")) {
+              violations.push({
+                file: posixFile,
+                subproject,
+                importTarget: relTarget,
+                resolvedTarget: resolved,
+                line: lineIdx + 1,
+                language: "go",
+                reason: `Cross-Module Boundary Violation: Go file "${posixFile}" in module "${subproject}" illegally imports relative path "${relTarget}" escaping module root.`,
+              });
+            }
+          }
+        }
+      }
+
+      // 3. Rust path attributes escaping crate
+      if (isRust) {
+        let match;
+        rustPathRegex.lastIndex = 0;
+        while ((match = rustPathRegex.exec(line)) !== null) {
+          const relTarget = match[1];
+          if (relTarget && relTarget.startsWith("..")) {
+            const resolved = toPosixPath(join(fileDir, relTarget));
+            const relToSubproject = toPosixPath(relative(subproject, resolved));
+            if (relToSubproject.startsWith("..")) {
+              violations.push({
+                file: posixFile,
+                subproject,
+                importTarget: relTarget,
+                resolvedTarget: resolved,
+                line: lineIdx + 1,
+                language: "rust",
+                reason: `Cross-Crate Boundary Violation: Rust file "${posixFile}" in crate "${subproject}" uses path attribute "${relTarget}" escaping crate root.`,
+              });
+            }
+          }
+        }
+      }
+
+      // 4. Python relative imports escaping package
+      if (isPython) {
+        let match;
+        pyRelImportRegex.lastIndex = 0;
+        while ((match = pyRelImportRegex.exec(line)) !== null) {
+          const dots = match[1];
+          const dotCount = (dots.match(/\./g) || []).length;
+          // Count depth from subproject to fileDir
+          const depth = fileDir === subproject ? 0 : fileDir.slice(subproject.length + 1).split("/").length;
+          if (dotCount > depth + 1) {
+            violations.push({
+              file: posixFile,
+              subproject,
+              importTarget: dots,
+              resolvedTarget: "<parent-package>",
+              line: lineIdx + 1,
+              language: "python",
+              reason: `Cross-Package Boundary Violation: Python file "${posixFile}" in package "${subproject}" uses relative import with ${dotCount} dots, escaping package root.`,
+            });
+          }
+        }
+      }
+    }
+  }
+
+  return violations;
+}
+
+/**
+ * Discovers monorepo packages and detects circular dependencies.
+ */
+export function detectCircularDependencies(root = process.cwd()) {
+  const packageMap = new Map(); // name -> { path, deps: [] }
+  const searchDirs = ["packages", "apps", "crates", "services", "libs", "modules", "backend", "frontend", "cli", "."];
+
+  for (const dir of searchDirs) {
+    const fullDir = join(root, dir);
+    if (!existsSync(fullDir)) continue;
+
+    const subDirs = dir === "." ? ["."] : [];
+    try {
+      if (dir !== ".") {
+        const entries = readdirSync(fullDir, { withFileTypes: true });
+        for (const e of entries) {
+          if (e.isDirectory()) subDirs.push(`${dir}/${e.name}`);
+        }
+      }
+    } catch (_) {}
+
+    for (const subDir of subDirs) {
+      const fullSubDir = join(root, subDir);
+      // 1. JS/TS package.json
+      const pkgJsonPath = join(fullSubDir, "package.json");
+      if (existsSync(pkgJsonPath)) {
+        try {
+          const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+          if (pkg.name) {
+            const allDeps = {
+              ...(pkg.dependencies || {}),
+              ...(pkg.devDependencies || {}),
+              ...(pkg.peerDependencies || {}),
+            };
+            packageMap.set(pkg.name, {
+              name: pkg.name,
+              path: subDir,
+              type: "npm",
+              deps: Object.keys(allDeps),
+            });
+          }
+        } catch (_) {}
+      }
+
+      // 2. Rust Cargo.toml
+      const cargoPath = join(fullSubDir, "Cargo.toml");
+      if (existsSync(cargoPath)) {
+        try {
+          const content = readFileSync(cargoPath, "utf-8");
+          const nameMatch = content.match(/\[package\][\s\S]*?name\s*=\s*["']([^"']+)["']/);
+          if (nameMatch) {
+            const crateName = nameMatch[1];
+            const deps = [];
+            const depMatches = content.matchAll(/([a-zA-Z0-9_-]+)\s*=\s*\{[^}]*?path\s*=\s*["']([^"']+)["']/g);
+            for (const dm of depMatches) {
+              deps.push(dm[1]);
+            }
+            packageMap.set(crateName, {
+              name: crateName,
+              path: subDir,
+              type: "cargo",
+              deps,
+            });
+          }
+        } catch (_) {}
+      }
+    }
+  }
+
+  // Filter dependencies to only workspace internal packages
+  const knownNames = new Set(packageMap.keys());
+  const graph = new Map();
+  for (const [name, info] of packageMap.entries()) {
+    graph.set(name, info.deps.filter((d) => knownNames.has(d)));
+  }
+
+  // Cycle detection via DFS
+  const cycles = [];
+  const visited = new Set();
+  const recStack = new Set();
+  const path = [];
+
+  function dfs(node) {
+    visited.add(node);
+    recStack.add(node);
+    path.push(node);
+
+    const neighbors = graph.get(node) || [];
+    for (const neighbor of neighbors) {
+      if (!visited.has(neighbor)) {
+        dfs(neighbor);
+      } else if (recStack.has(neighbor)) {
+        const cycleStartIndex = path.indexOf(neighbor);
+        const cycle = path.slice(cycleStartIndex).concat(neighbor);
+        cycles.push(cycle.join(" -> "));
+      }
+    }
+
+    path.pop();
+    recStack.delete(node);
+  }
+
+  for (const node of graph.keys()) {
+    if (!visited.has(node)) {
+      dfs(node);
+    }
+  }
+
+  return {
+    hasCycles: cycles.length > 0,
+    cycles,
+    packages: Array.from(packageMap.values()),
+  };
+}
+
 /**
  * Resolves workspace boundaries in polyglot monorepos by mapping changed files to subprojects.
  */
-export function resolveWorkspaceBoundary(changedFiles = [], root = process.cwd()) {
+export function resolveWorkspaceBoundary(changedFiles = [], root = process.cwd(), options = {}) {
   const rootStack = detectPolyglotStack(root);
+  const boundaryViolations = detectCrossPackageBoundaryViolations(changedFiles, root, options);
+  const circular = detectCircularDependencies(root);
+
   if (!changedFiles || changedFiles.length === 0) {
-    return { isMonorepo: false, globalFallback: false, projects: [{ path: ".", ...rootStack }], testCmd: rootStack.testCmd, buildCmd: rootStack.buildCmd };
+    return {
+      isMonorepo: circular.packages.length > 1,
+      globalFallback: false,
+      projects: [{ path: ".", ...rootStack }],
+      testCmd: rootStack.testCmd,
+      buildCmd: rootStack.buildCmd,
+      boundaryViolations,
+      circularDependencies: circular.cycles,
+    };
   }
 
   const sharedTriggers = new Set(["openapi.yaml", "openapi.json", "schema.graphql", "docker-compose.yml", "Makefile", "turbo.json", "pnpm-workspace.yaml", "nx.json"]);
   for (const file of changedFiles) {
-    const baseName = file.split(sep).pop();
+    const baseName = toPosixPath(file).split("/").pop();
     if (sharedTriggers.has(baseName) || file.startsWith(".agent/") || file.startsWith(".github/")) {
-      return { isMonorepo: true, globalFallback: true, projects: [{ path: ".", ...rootStack }], testCmd: rootStack.testCmd, buildCmd: rootStack.buildCmd };
+      return {
+        isMonorepo: true,
+        globalFallback: true,
+        projects: [{ path: ".", ...rootStack }],
+        testCmd: rootStack.testCmd,
+        buildCmd: rootStack.buildCmd,
+        boundaryViolations,
+        circularDependencies: circular.cycles,
+      };
     }
   }
 
   const projectMap = new Map();
   for (const file of changedFiles) {
-    const parts = file.split(sep);
-    let resolved = false;
-
-    for (let i = parts.length - 1; i >= 1; i--) {
-      const subDir = parts.slice(0, i).join("/");
+    const subDir = findSubprojectRoot(file, root);
+    if (subDir !== ".") {
       const subStack = detectPolyglotStack(join(root, subDir));
-      if (subStack.stack !== "unknown" && subStack.triggerFile) {
-        if (!projectMap.has(subDir)) {
-          projectMap.set(subDir, { path: subDir, ...subStack });
-        }
-        resolved = true;
-        break;
+      if (!projectMap.has(subDir)) {
+        projectMap.set(subDir, { path: subDir, ...subStack });
+      }
+    } else {
+      if (!projectMap.has(".")) {
+        projectMap.set(".", { path: ".", ...rootStack });
       }
-    }
-
-    if (!resolved && !projectMap.has(".")) {
-      projectMap.set(".", { path: ".", ...rootStack });
     }
   }
 
@@ -278,11 +627,13 @@ export function resolveWorkspaceBoundary(changedFiles = [], root = process.cwd()
     .map((p) => (p.path === "." ? p.buildCmd : `(cd ${p.path} && ${p.buildCmd})`));
 
   return {
-    isMonorepo: projects.length > 1,
+    isMonorepo: projects.length > 1 || circular.packages.length > 1,
     globalFallback: false,
     projects,
     testCmd: testCmds.join(" && ") || rootStack.testCmd,
     buildCmd: buildCmds.join(" && ") || rootStack.buildCmd,
+    boundaryViolations,
+    circularDependencies: circular.cycles,
   };
 }
 

package/src/wizard-task.mjs

@@ -1,5 +1,5 @@
-import { writeFileSync, mkdirSync, existsSync } from "node:fs";
-import { resolve } from "node:path";
+import { writeFileSync, readFileSync, readdirSync, mkdirSync, existsSync } from "node:fs";
+import { resolve, join } from "node:path";
 import { loadConfig } from "./config.mjs";
 import { gate } from "./engine.mjs";
 import { scanDiff, shannonEntropy } from "./security.mjs";
@@ -21,9 +21,38 @@ HARD CONSTRAINTS:
 
 const TRIVIAL_ORACLES = new Set(["true", "echo", ":", "false", "exit 0", "exit 1", "echo ok"]);
 
+/**
+ * Resolves specialist agent role markdown prompt from .agent/prompts/
+ * @param {string} [root=process.cwd()]
+ * @param {string} [roleName=""]
+ * @returns {{ role: string, path: string, content: string } | null}
+ */
+export function resolveRolePrompt(root = process.cwd(), roleName = "") {
+  if (!roleName || typeof roleName !== "string") return null;
+  const cleanName = roleName.trim().toLowerCase();
+  const promptsDir = join(root, ".agent", "prompts");
+  if (!existsSync(promptsDir)) return null;
+
+  try {
+    const files = readdirSync(promptsDir);
+    const matched = files.find(
+      (f) => f.toLowerCase() === `${cleanName}.md` || f.toLowerCase() === cleanName
+    );
+    if (matched) {
+      const fullPath = join(promptsDir, matched);
+      return {
+        role: matched.replace(/\.md$/i, ""),
+        path: fullPath,
+        content: readFileSync(fullPath, "utf-8").trim(),
+      };
+    }
+  } catch (_) {}
+  return null;
+}
+
 /**
  * Pure planning core for task creation & envelope synthesis.
- * Supports web task templates, exploration budgets, and critic agent steering.
+ * Supports web task templates, specialist roles, exploration budgets, and critic agent steering.
  * @param {string} root
  * @param {object} inputObj
  * @returns {{
@@ -33,6 +62,8 @@ const TRIVIAL_ORACLES = new Set(["true", "echo", ":", "false", "exit 0", "exit 1
  *   prompt: string,
  *   fullPrompt: string,
  *   verifyCmd: string,
+ *   role?: string,
+ *   dependsOn?: string[],
  *   flags: { autoPr: boolean, requirePlanApproval: boolean, repoless: boolean, startingBranch: string },
  *   secretFindings: Array<any>,
  *   taskFileContent: string
@@ -45,7 +76,22 @@ export function planTaskCreate(root = process.cwd(), inputObj = {}) {
   let rawPrompt = inputObj.prompt || "";
   let verifyCmd = (inputObj.verifyCmd || config.verify.test || config.verify.build || "").trim();
 
-  // 0. Process Template if specified
+  // 0a. Process Specialist Role if specified
+  let resolvedRole = null;
+  if (inputObj.role) {
+    resolvedRole = resolveRolePrompt(root, inputObj.role);
+    if (!resolvedRole) {
+      throw new Error(
+        `Unknown agent role '${inputObj.role}'. Expected matching prompt file in .agent/prompts/ (e.g. Overseer, Bolt, Sentinel, Janitor).`
+      );
+    }
+    rawPrompt = `${resolvedRole.content}\n\n${rawPrompt}`.trim();
+    if (!title || title === "Agent Task") {
+      title = `${resolvedRole.role}: ${inputObj.title || "Specialist Task"}`;
+    }
+  }
+
+  // 0b. Process Template if specified
   if (inputObj.template) {
     const tpl = getWebTemplate(inputObj.template);
     if (!tpl) {
@@ -57,7 +103,7 @@ export function planTaskCreate(root = process.cwd(), inputObj = {}) {
       criticGuidance: inputObj.criticGuidance
     });
     rawPrompt = rawPrompt ? `${rawPrompt}\n\n${synthesized.prompt}` : synthesized.fullEnvelope;
-    if (!title) title = synthesized.title;
+    if (!title || title === "Agent Task") title = synthesized.title;
     if (!verifyCmd) verifyCmd = synthesized.verifyCmd;
   }
 
@@ -123,12 +169,24 @@ ${GUARDRAIL_FOOTER}`;
 
   const promptAnalysis = scorePromptFalsifiability(rawPrompt, { rootDir: root, verifyCmd });
 
+  const rawDepends = inputObj.dependsOn || inputObj.depends;
+  const dependsOn = Array.isArray(rawDepends)
+    ? rawDepends
+    : typeof rawDepends === "string"
+    ? rawDepends.split(",").map((s) => s.trim()).filter(Boolean)
+    : undefined;
+
+  const tier = inputObj.tier === "fast" || inputObj.tier === "complex" ? inputObj.tier : undefined;
+
   const envelopeMetadata = {
     version: 1,
     id: taskId,
     title,
     flags,
     verifyCmd,
+    role: resolvedRole ? resolvedRole.role : (inputObj.role || undefined),
+    dependsOn,
+    tier,
     falsifiabilityScore: promptAnalysis.score,
     grade: promptAnalysis.grade,
   };
@@ -148,6 +206,9 @@ ${fullPrompt}
     prompt: rawPrompt,
     fullPrompt,
     verifyCmd,
+    role: envelopeMetadata.role,
+    dependsOn,
+    tier,
     flags,
     secretFindings,
     promptAnalysis,