jules-orchestrator-kit 0.74.0 → 0.75.1

package/src/uninstall.mjs

@@ -0,0 +1,227 @@
+/**
+ * Undo a default `agentctl init`: remove kit-owned config and the runtime
+ * `.gitignore` block. Optional `--force` also removes legacy scaffold dirs.
+ *
+ * See docs/uninstall.md — this deliberately does not delete AGENTS.md,
+ * SPEC.md, or other paths that may contain project-owned content.
+ */
+
+import { existsSync, readFileSync, writeFileSync, rmSync, readdirSync, rmdirSync } from "node:fs";
+import { join } from "node:path";
+import {
+  RUNTIME_GITIGNORE_HEADER,
+  stripRuntimeGitignoreBlock,
+} from "./scaffold.mjs";
+
+/** Legacy scaffold directories owned by `init --force` / older 0.x releases. */
+export const FORCE_REMOVE_DIRS = [
+  ".agent/rules",
+  ".agent/prompts",
+  ".agent/workflows",
+  ".agent/jules-queue",
+];
+
+/**
+ * @param {string} content
+ * @returns {boolean}
+ */
+export function looksLikeKitConfig(content) {
+  const text = String(content);
+  if (text.includes("Agent Orchestrator Kit Config")) return true;
+  // Minimal shape init writes: a versioned manifest with a provider key.
+  return /^version:\s*\d+/m.test(text) && /^provider:\s*\S+/m.test(text);
+}
+
+/**
+ * @param {string} root
+ * @returns {{ installed: boolean, hasConfig: boolean, hasGitignoreBlock: boolean, configPath: string|null }}
+ */
+export function detectKitInstallation(root) {
+  const configPath = join(root, ".agent", "config.yml");
+  let hasConfig = false;
+  if (existsSync(configPath)) {
+    try {
+      hasConfig = looksLikeKitConfig(readFileSync(configPath, "utf-8"));
+    } catch (_) {
+      hasConfig = false;
+    }
+  }
+
+  let hasGitignoreBlock = false;
+  const gitignorePath = join(root, ".gitignore");
+  if (existsSync(gitignorePath)) {
+    try {
+      hasGitignoreBlock = readFileSync(gitignorePath, "utf-8").includes(RUNTIME_GITIGNORE_HEADER);
+    } catch (_) {
+      hasGitignoreBlock = false;
+    }
+  }
+
+  return {
+    installed: hasConfig || hasGitignoreBlock,
+    hasConfig,
+    hasGitignoreBlock,
+    configPath: hasConfig ? ".agent/config.yml" : null,
+  };
+}
+
+/**
+ * @param {string} root
+ * @param {{ force?: boolean }} [options]
+ * @returns {{
+ *   ok: boolean,
+ *   installed: boolean,
+ *   willRemove: string[],
+ *   willCleanGitignore: boolean,
+ *   forceDirs: string[],
+ *   error?: string,
+ * }}
+ */
+export function planUninstall(root, options = {}) {
+  const force = Boolean(options.force);
+  const detection = detectKitInstallation(root);
+  if (!detection.installed) {
+    return {
+      ok: false,
+      installed: false,
+      willRemove: [],
+      willCleanGitignore: false,
+      forceDirs: [],
+      error: "No kit installation detected (missing .agent/config.yml and runtime gitignore block).",
+    };
+  }
+
+  const willRemove = [];
+  if (detection.hasConfig) willRemove.push(".agent/config.yml");
+
+  const forceDirs = [];
+  if (force) {
+    for (const rel of FORCE_REMOVE_DIRS) {
+      if (existsSync(join(root, rel))) forceDirs.push(rel);
+    }
+    willRemove.push(...forceDirs);
+  }
+
+  const willCleanGitignore = detection.hasGitignoreBlock;
+  if (willCleanGitignore) willRemove.push(".gitignore");
+
+  // `.agent/` itself is only removed when it would be empty after the planned
+  // deletions — reported so dry-run matches real execution.
+  const agentDir = join(root, ".agent");
+  if (existsSync(agentDir) && wouldAgentDirBeEmpty(root, {
+    removeConfig: detection.hasConfig,
+    forceDirs,
+  })) {
+    willRemove.push(".agent");
+  }
+
+  return {
+    ok: true,
+    installed: true,
+    willRemove: [...new Set(willRemove)],
+    willCleanGitignore,
+    forceDirs,
+  };
+}
+
+/**
+ * @param {string} root
+ * @param {{ removeConfig: boolean, forceDirs: string[] }} planned
+ */
+function wouldAgentDirBeEmpty(root, planned) {
+  const agentDir = join(root, ".agent");
+  if (!existsSync(agentDir)) return false;
+  let entries;
+  try {
+    entries = readdirSync(agentDir);
+  } catch (_) {
+    return false;
+  }
+  const removing = new Set();
+  if (planned.removeConfig) removing.add("config.yml");
+  for (const rel of planned.forceDirs) {
+    if (rel.startsWith(".agent/")) removing.add(rel.slice(".agent/".length).split("/")[0]);
+  }
+  return entries.every((name) => removing.has(name));
+}
+
+/**
+ * @param {string} root
+ * @param {{ force?: boolean, dryRun?: boolean }} [options]
+ * @returns {{
+ *   ok: boolean,
+ *   dryRun: boolean,
+ *   installed: boolean,
+ *   willRemove?: string[],
+ *   removed?: string[],
+ *   willCleanGitignore?: boolean,
+ *   cleanedGitignore?: boolean,
+ *   error?: string,
+ * }}
+ */
+export function uninstallKit(root, options = {}) {
+  const dryRun = Boolean(options.dryRun);
+  const force = Boolean(options.force);
+  const plan = planUninstall(root, { force });
+  if (!plan.ok) {
+    return { ok: false, dryRun, installed: false, error: plan.error };
+  }
+
+  if (dryRun) {
+    return {
+      ok: true,
+      dryRun: true,
+      installed: true,
+      willRemove: plan.willRemove,
+      willCleanGitignore: plan.willCleanGitignore,
+    };
+  }
+
+  const removed = [];
+
+  const configAbs = join(root, ".agent", "config.yml");
+  if (plan.willRemove.includes(".agent/config.yml") && existsSync(configAbs)) {
+    rmSync(configAbs, { force: true });
+    removed.push(".agent/config.yml");
+  }
+
+  for (const rel of plan.forceDirs) {
+    const abs = join(root, rel);
+    if (existsSync(abs)) {
+      rmSync(abs, { recursive: true, force: true });
+      removed.push(rel);
+    }
+  }
+
+  let cleanedGitignore = false;
+  const gitignorePath = join(root, ".gitignore");
+  if (plan.willCleanGitignore && existsSync(gitignorePath)) {
+    const current = readFileSync(gitignorePath, "utf-8");
+    const { text, stripped } = stripRuntimeGitignoreBlock(current);
+    if (stripped) {
+      writeFileSync(gitignorePath, text, "utf-8");
+      cleanedGitignore = true;
+      removed.push(".gitignore");
+    }
+  }
+
+  const agentDir = join(root, ".agent");
+  if (existsSync(agentDir)) {
+    try {
+      if (readdirSync(agentDir).length === 0) {
+        rmdirSync(agentDir);
+        removed.push(".agent");
+      }
+    } catch (_) {
+      // Leave the directory if it is not empty or not removable.
+    }
+  }
+
+  return {
+    ok: true,
+    dryRun: false,
+    installed: true,
+    removed: [...new Set(removed)],
+    cleanedGitignore,
+  };
+}

package/src/wizard-init.mjs

@@ -122,6 +122,17 @@ export function planInit(root = process.cwd(), options = {}) {
   // scaffolded limits always match what the runtime will later enforce.
   const tierPresetLimits = TIER_PROFILES[tierName] || TIER_PROFILES[FALLBACK_TIER];
 
+  // Same fail-closed rule as tier: an explicit `--profile` that is not one of
+  // PROFILE_NAMES must not silently become `standard`. Guessing wrong used to
+  // scaffold the everyday gate under a name the operator never chose.
+  if (options.profile && !PROFILE_NAMES.includes(String(options.profile).toLowerCase())) {
+    const rawProfile = String(options.profile).toLowerCase();
+    if (validTiers.includes(rawProfile)) {
+      throw new Error(`Invalid profile "${options.profile}". Valid profiles: ${PROFILE_NAMES.join(", ")}. Did you mean '--tier ${options.profile}'?`);
+    }
+    throw new Error(`Invalid profile "${options.profile}". Valid profiles: ${PROFILE_NAMES.join(", ")}.`);
+  }
+
   // Preserve existing config if present (ignored when pristine requested)
   let existingConfig = {};
   if (!options.pristine) {

package/src/wizard-task.mjs

@@ -1,5 +1,5 @@
 import { writeFileSync, mkdirSync, existsSync } from "node:fs";
-import { resolve, join } from "node:path";
+import { resolve } from "node:path";
 import { untrackedOnboardingArtifacts } from "./git.mjs";
 import { loadConfig } from "./config.mjs";
 import { gate } from "./engine.mjs";
@@ -220,33 +220,22 @@ export function planTaskCreate(root = process.cwd(), inputObj = {}) {
   const rawId = inputObj.id || `TASK-${Date.now().toString(36).toUpperCase()}`;
   const taskId = String(rawId).replace(/[^a-zA-Z0-9_-]/g, "_");
 
-  const hasAstro = existsSync(join(root, "astro.config.mjs")) || existsSync(join(root, "astro.config.ts"));
-  const hasWrangler =
-    existsSync(join(root, "wrangler.jsonc")) ||
-    existsSync(join(root, "wrangler.json")) ||
-    existsSync(join(root, "wrangler.toml"));
-
+  const configInvariants = Array.isArray(config.invariants) ? config.invariants : [];
   const autoInvariants = [
     "Preserve existing signatures, surrounding logic, and coding style.",
     "Do not modify files outside scope.allow.",
+    ...configInvariants,
   ];
-  if (hasAstro) {
-    autoInvariants.push("Zero-JS runtime-princip: skicka noll onödig klient-JS i src/ och använd plana <img> framför Astro <Image>.");
-  }
-  if (hasWrangler) {
-    autoInvariants.push("Edge runtime constraints: inga otillåtna Node-imports (t.ex. node:fs, node:path, sharp) i workerd runtime-kod.");
-  }
   const invariants = Array.isArray(inputObj.invariants) && inputObj.invariants.length > 0
     ? inputObj.invariants
     : autoInvariants;
 
-  const autoMcpDirectives = [];
-  if (hasAstro) autoMcpDirectives.push("astro-docs");
-  if (hasWrangler) autoMcpDirectives.push("cloudflare-docs");
-  if (existsSync(join(root, "emdash.config.ts"))) autoMcpDirectives.push("emdash-docs");
-  if (autoMcpDirectives.length > 0) autoMcpDirectives.push("context7");
-
-  const mcpDirectives = inputObj.mcpDirectives || inputObj.mcp_directives || (autoMcpDirectives.length > 0 ? autoMcpDirectives : undefined);
+  const configDirectives = Array.isArray(config.mcp_directives)
+    ? config.mcp_directives
+    : Array.isArray(config.mcpDirectives)
+      ? config.mcpDirectives
+      : [];
+  const mcpDirectives = inputObj.mcpDirectives || inputObj.mcp_directives || (configDirectives.length > 0 ? configDirectives : undefined);
   const mcpDirectiveLine = mcpDirectives && mcpDirectives.length > 0
     ? `MCP DIRECTIVE: Mandating pre-execution documentation lookup via [${mcpDirectives.join(" | ")}] before modifying code.\n\n`
     : "";
@@ -476,7 +465,7 @@ export async function runTaskCreateWizard(root = process.cwd(), options = {}) {
   });
 
   // Perform Gate Preflight
-  const gateRes = await gate({ root, mode: "working-tree" });
+  const gateRes = await gate({ root, mode: "working-tree", allowProtected: Boolean(options.allowProtected) });
   if (!gateRes.ok && (gateRes.code === 3 || gateRes.code === 6) && !options.allowGateFailure) {
     const scopeViolations = gateRes.phases[0]?.violations || [];
     // A cold-start repository has nothing committed yet: every path init just
@@ -491,7 +480,13 @@ export async function runTaskCreateWizard(root = process.cwd(), options = {}) {
     const realViolations = scopeViolations.filter((v) => !v.file.startsWith(".agent/")) || [];
     const installArtifacts = new Set(untrackedOnboardingArtifacts(root, scopeViolations.map((v) => v.file)));
     const blockers = realViolations.filter((v) => !installArtifacts.has(v.file));
-    if (blockers.length > 0 || gateRes.code === 6) {
+    if (blockers.length > 0) {
+      const fileList = blockers.map((b) => b.file).join(", ");
+      throw new Error(
+        `Gate Preflight Rejected Task: Repository contains scope violations in protected/denied paths: ${fileList} (Exit 3).\n   To permit protected paths for this task, re-run with --allow-protected.`
+      );
+    }
+    if (gateRes.code === 6) {
       throw new Error(`Gate Preflight Rejected Task: Repository contains scope or secret violations (Exit ${gateRes.code}).`);
     }
   }