jules-orchestrator-kit 0.8.5 → 0.9.3

package/scripts/lock-manager.mjs

@@ -1,188 +1,22 @@
-#!/usr/bin/env node
-
 /**
- * lock-manager.mjs
- * 
- * Manages multi-agent file locks to prevent concurrent modification collisions.
- * Uses .agent/sync-manifest.json as the lock registry.
- * 
- * Usage:
- *   node scripts/lock-manager.mjs acquire <agent_name> <task_id> <file_path1> <file_path2> [--unattended]
- *   node scripts/lock-manager.mjs release <task_id>
+ * Backward compatibility shim for lock-manager.mjs in v0.9.0.
+ * Delegates to src/state.mjs.
  */
 
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const MANIFEST_PATH = path.join(process.cwd(), '.agent', 'file-locks.json');
-const TTL_MS = 20 * 60 * 1000; // 20 minutes
-const isMainModule = process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url));
+import { acquireLock, releaseLock, lockStatus } from "../src/state.mjs";
 
-async function readManifest() {
-  try {
-    const data = await fs.readFile(MANIFEST_PATH, 'utf-8');
-    return JSON.parse(data);
-  } catch (err) {
-    if (err.code === 'ENOENT') {
-      return {};
-    }
-    throw err;
-  }
+export function acquire(agent, taskId, filePaths = [], opts = {}) {
+  return acquireLock(agent, taskId, filePaths, opts);
 }
 
-async function writeManifest(manifest) {
-  await fs.mkdir(path.dirname(MANIFEST_PATH), { recursive: true });
-  const tmp = MANIFEST_PATH + `.tmp-${process.pid}`;
-  await fs.writeFile(tmp, JSON.stringify(manifest, null, 2), 'utf-8');
-  await fs.rename(tmp, MANIFEST_PATH);
-}
-
-async function withManifestLock(fn) {
-  const lockPath = MANIFEST_PATH + ".lock";
-  await fs.mkdir(path.dirname(lockPath), { recursive: true });
-  for (let i = 0; i < 50; i++) {
-    try {
-      const stats = await fs.stat(lockPath);
-      if (Date.now() - stats.mtimeMs > 5 * 60 * 1000) {
-        await fs.rm(lockPath, { force: true });
-      }
-    } catch (_) {}
-
-    let handle;
-    try {
-      handle = await fs.open(lockPath, "wx");
-    } catch (err) {
-      if (err.code !== "EEXIST") throw err;
-      await new Promise(r => setTimeout(r, 50 + Math.random() * 50));
-      continue;
-    }
-    try { return await fn(); }
-    finally {
-      try { await handle.close(); } catch (_) {}
-      await fs.rm(lockPath, { force: true });
-    }
-  }
-  throw new Error("Could not acquire manifest lock");
+export function release(agent, taskId, opts = {}) {
+  return releaseLock(agent, taskId, opts);
 }
 
-function cleanExpiredLocks(manifest) {
-  const now = Date.now();
-  let changed = false;
-  for (const [file, lock] of Object.entries(manifest)) {
-    if (lock.expiresAt < now) {
-      delete manifest[file];
-      changed = true;
-    }
-  }
-  return changed;
-}
-
-async function acquireLocks(agentName, taskId, files, isUnattended = false) {
-  await withManifestLock(async () => {
-    if (isUnattended) {
-      console.log(`[lock-manager] Operating in unattended mode for task ${taskId}`);
-    }
-    const manifest = await readManifest();
-  cleanExpiredLocks(manifest);
-  
-  const now = Date.now();
-  const expiresAt = now + TTL_MS;
-
-  const conflicts = [];
-  for (const file of files) {
-    const normalizedFile = path.normalize(file);
-    if (manifest[normalizedFile] && manifest[normalizedFile].taskId !== taskId) {
-      conflicts.push({
-        file: normalizedFile,
-        lockedBy: manifest[normalizedFile].agentName,
-        task: manifest[normalizedFile].taskId
-      });
-    }
-  }
-
-    if (conflicts.length > 0) {
-      let msg = `Cannot acquire locks for task ${taskId}. Conflicts detected:\n`;
-      for (const conflict of conflicts) {
-        msg += `  - ${conflict.file} is locked by ${conflict.lockedBy} (Task: ${conflict.task})\n`;
-      }
-      throw new Error(msg.trim());
-    }
-
-  for (const file of files) {
-    const normalizedFile = path.normalize(file);
-    manifest[normalizedFile] = {
-      agentName,
-      taskId,
-      acquiredAt: now,
-      expiresAt
-    };
-  }
-
-    await writeManifest(manifest);
-    console.log(`SUCCESS: Acquired locks for task ${taskId} on ${files.length} files.`);
-  });
-}
-
-async function releaseLocks(taskId) {
-  await withManifestLock(async () => {
-    const manifest = await readManifest();
-  let releasedCount = 0;
-  
-  for (const [file, lock] of Object.entries(manifest)) {
-    if (lock.taskId === taskId) {
-      delete manifest[file];
-      releasedCount++;
-    }
-  }
-
-    if (releasedCount > 0) {
-      await writeManifest(manifest);
-      console.log(`SUCCESS: Released ${releasedCount} locks for task ${taskId}.`);
-    } else {
-      console.log(`INFO: No locks found for task ${taskId}.`);
-    }
-  });
-}
-
-async function main() {
-  const args = process.argv.slice(2);
-  const command = args[0];
-
-  if (command === 'acquire') {
-    const agentName = args[1];
-    const taskId = args[2];
-    const unattendedIndex = args.indexOf('--unattended');
-    const isUnattended = unattendedIndex !== -1;
-    let files = [];
-    if (isUnattended) {
-       files = args.slice(3, unattendedIndex).concat(args.slice(unattendedIndex + 1));
-    } else {
-       files = args.slice(3);
-    }
-    
-    if (!agentName || !taskId || files.length === 0) {
-      console.error('Usage: acquire <agent_name> <task_id> <file_paths...> [--unattended]');
-      process.exit(1);
-    }
-    
-    await acquireLocks(agentName, taskId, files, isUnattended);
-  } else if (command === 'release') {
-    const taskId = args[1];
-    if (!taskId) {
-      console.error('Usage: release <task_id>');
-      process.exit(1);
-    }
-    await releaseLocks(taskId);
-  } else {
-    console.error('Unknown command. Use "acquire" or "release".');
-    process.exit(1);
-  }
+export function status(opts = {}) {
+  return lockStatus(opts);
 }
 
-if (isMainModule) {
-  main().catch(err => {
-    console.error('Unhandled error:', err);
-    process.exit(1);
-  });
+export function cleanup() {
+  return { removed: 0 };
 }

package/scripts/risk-tier.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+import { changedFiles } from "../src/git.mjs";
+import { classifyRiskTier } from "../src/risk.mjs";
+
+const root = process.cwd();
+const baseBranch = process.env.BASE_BRANCH || "main";
+
+try {
+  const files = changedFiles(root, baseBranch);
+  const result = classifyRiskTier(files);
+
+  console.log(`[risk-tier] Classified PR Risk Tier: ${result.tier}`);
+  console.log(`[risk-tier] Reason: ${result.reason}`);
+  console.log(`[risk-tier] Auto-Merge Allowed: ${result.isAutoMergeAllowed}`);
+  console.log(`[risk-tier] Requires Human Review: ${result.requiresHumanReview}`);
+
+  if (process.env.GITHUB_OUTPUT) {
+    const { appendFileSync } = await import("node:fs");
+    appendFileSync(process.env.GITHUB_OUTPUT, `risk_tier=${result.tier}\n`);
+    appendFileSync(process.env.GITHUB_OUTPUT, `auto_merge=${result.isAutoMergeAllowed}\n`);
+    appendFileSync(process.env.GITHUB_OUTPUT, `requires_human=${result.requiresHumanReview}\n`);
+  }
+
+  process.exit(0);
+} catch (err) {
+  console.error(`❌ Risk tier classification failed: ${err.message}`);
+  process.exit(1);
+}

package/scripts/rules-lint.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+import { checkRulesBudget } from "../src/rules_budget.mjs";
+
+const root = process.cwd();
+const res = checkRulesBudget(root);
+
+console.log("[rules-lint] Auditing character and line budgets for agent rule files...");
+
+if (!res.ok) {
+  console.error("❌ RULES BUDGET VIOLATIONS DETECTED:");
+  for (const v of res.violations) {
+    console.error(`  - ${v.path}: ${v.reason}`);
+  }
+  console.error("\nRemediation: Trim prose rules or convert textual learnings into AST lints / Vitest assertions.");
+  process.exit(1);
+}
+
+console.log("✅ All agent rule files are within safe character (<10,000) and line (<250) budget limits.");
+process.exit(0);

package/scripts/stale-base-check.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+import { git, resolveBase } from "../src/git.mjs";
+
+const root = process.cwd();
+const maxBehind = parseInt(process.env.STALE_BASE_MAX_COMMITS || "25", 10);
+const baseBranch = process.env.BASE_BRANCH || "main";
+
+try {
+  const resolvedBase = resolveBase(root, baseBranch);
+  const behindStr = git(["rev-list", "--count", `${resolvedBase}..HEAD`], { cwd: root, ignoreError: true });
+  const behindCount = parseInt(behindStr || "0", 10);
+
+  console.log(`[stale-base-check] Branch HEAD is ${behindCount} commits behind ${resolvedBase} (max allowed: ${maxBehind}).`);
+
+  if (!isNaN(behindCount) && behindCount > maxBehind) {
+    console.error(`❌ STALE BASE GATE FAIL: PR branch is ${behindCount} commits behind ${resolvedBase}. Rebase onto latest ${baseBranch} before merging.`);
+    process.exit(1);
+  }
+
+  console.log("✅ Stale-base predicate check passed.");
+  process.exit(0);
+} catch (err) {
+  console.warn(`⚠️ Stale-base check skipped (git base ref not available or shallow clone): ${err.message}`);
+  process.exit(0);
+}