deuk-agent-rule 2.5.13 → 3.3.2

package/scripts/cli-init-logic.mjs

@@ -1,9 +1,24 @@
 import { existsSync, appendFileSync, writeFileSync, mkdirSync, readFileSync } from "fs";
 import { join } from "path";
-import { AGENT_ROOT_DIR, TICKET_DIR_NAME } from "./cli-utils.mjs";
+import { AGENT_ROOT_DIR, LEGACY_IGNORE_DIR, LEGACY_TICKET_DIR, LEGACY_TICKET_DIR_PLURAL, TICKET_DIR_NAME } from "./cli-utils.mjs";
 
 const GITIGNORE_AGENT_MARKER = "# deuk-agent-rule: agent hub directory (local, not committed by default)";
 
+function hasExactGitignoreLine(content, line) {
+  return content
+    .split(/\r?\n/)
+    .map(s => s.trim())
+    .includes(line);
+}
+
+function removeExactGitignoreLines(content, lines) {
+  const remove = new Set(lines);
+  return content
+    .split(/\r?\n/)
+    .filter(line => !remove.has(line.trim()))
+    .join("\n");
+}
+
 export function ensureTicketDirAndGitignore(opts) {
   const ticketPath = join(opts.cwd, TICKET_DIR_NAME);
   const gitignorePath = join(opts.cwd, ".gitignore");
@@ -21,24 +36,21 @@ export function ensureTicketDirAndGitignore(opts) {
   
   // 1. Create document directories
   const docsPath = join(opts.cwd, AGENT_ROOT_DIR, "docs");
-  mkdirSync(join(docsPath, "plans"), { recursive: true });
-  mkdirSync(join(docsPath, "walkthroughs"), { recursive: true });
-  mkdirSync(join(docsPath, "scratch"), { recursive: true });
-
-  // 2. Ignore docs/scratch/ always
-  const scratchIgnoreLine = `${AGENT_ROOT_DIR}/docs/scratch/`;
-  if (!gi.includes(scratchIgnoreLine)) {
-    appendFileSync(gitignorePath, "\n" + scratchIgnoreLine + "\n", "utf8");
-    console.log(`[INIT] Added ${scratchIgnoreLine} to .gitignore`);
-    gi += "\n" + scratchIgnoreLine + "\n";
-  }
+  mkdirSync(join(docsPath, "plan"), { recursive: true });
+  mkdirSync(join(docsPath, "archive"), { recursive: true });
 
   // Also check for legacy ignore lines to clean up or at least check presence
-  const legacyIgnore1 = ".deuk-agent-ticket/";
-  const legacyIgnore2 = ".deuk-agent-tickets/";
-  const legacyIgnore3 = ".deuk-agent/tickets/";
+  const legacyIgnore1 = `${LEGACY_TICKET_DIR}/`;
+  const legacyIgnore2 = `${LEGACY_TICKET_DIR_PLURAL}/`;
+  const legacyIgnore3 = LEGACY_IGNORE_DIR;
+  const cleanedGi = removeExactGitignoreLines(gi, [legacyIgnore1, legacyIgnore2, legacyIgnore3]);
+  if (cleanedGi !== gi) {
+    writeFileSync(gitignorePath, cleanedGi.replace(/\n*$/, "\n"), "utf8");
+    gi = cleanedGi;
+    console.log("[INIT] Removed legacy deuk-agent-rule .gitignore entries");
+  }
 
-  if (!gi.includes(ignoreLine) && !opts.shareTickets) {
+  if (!hasExactGitignoreLine(gi, ignoreLine) && !opts.shareTickets) {
     const block = "\n" + GITIGNORE_AGENT_MARKER + "\n" + ignoreLine + "\n";
     appendFileSync(gitignorePath, block, "utf8");
     console.log(`[INIT] Added ${ignoreLine} to .gitignore`);

package/scripts/cli-prompts.mjs

@@ -1,7 +1,7 @@
 import { createInterface } from "readline";
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
-import { loadInitConfig, writeInitConfig, STACKS, AGENT_TOOLS } from "./cli-utils.mjs";
+import { STACKS, AGENT_TOOLS, DOC_LANGUAGE_CHOICES, resolveDocsLanguage, normalizeWorkflowMode, WORKFLOW_MODE_EXECUTE, WORKFLOW_MODE_PLAN } from "./cli-utils.mjs";
 
 export async function ask(rl, question) {
   return new Promise((resolve) => rl.question(question, resolve));
@@ -48,6 +48,13 @@ export async function runInteractive(opts) {
 
     const stack = await selectOne(rl, "What is your primary tech stack?", STACKS);
     const tools = await selectMany(rl, "Which agent tools do you use?", AGENT_TOOLS);
+    const docsLanguage = await selectOne(rl, "What document language should generated tickets/plans use?", DOC_LANGUAGE_CHOICES);
+    const workflowMode = opts.workflowMode
+      ? normalizeWorkflowMode(opts.workflowMode)
+      : await selectOne(rl, "What workflow mode should be saved?", [
+          { label: "Plan mode (prepare only)", value: WORKFLOW_MODE_PLAN },
+          { label: "Execute mode (apply changes)", value: WORKFLOW_MODE_EXECUTE },
+        ]);
     const shareTickets = await askYesNo("Do you want to share (git-track) tickets for this repository?", false);
 
     const targetAgents = join(opts.cwd, "AGENTS.md");
@@ -57,7 +64,7 @@ export async function runInteractive(opts) {
       console.log("\n  No AGENTS.md found — will create with markers.");
     } else {
       const content = readFileSync(targetAgents, "utf8");
-      const hasMarkers = content.includes("deuk-agent-rule:begin");
+      const hasMarkers = content.includes("deuk-agent-rule:begin") || content.includes("## DeukAgentRules");
       if (!hasMarkers) {
         const choice = await selectOne(rl, "AGENTS.md exists but has no markers. How to apply?", [
           { label: "Append managed block at the end (safe)", value: "inject" },
@@ -77,14 +84,16 @@ export async function runInteractive(opts) {
     opts.agents = opts.agents ?? agentsDefault;
     opts.stack = stack;
     opts.agentTools = tools;
+    opts.docsLanguage = resolveDocsLanguage(docsLanguage);
+    opts.workflowMode = normalizeWorkflowMode(opts.workflowMode || workflowMode);
     opts.shareTickets = shareTickets;
     opts.remoteSync = remoteSync;
     opts.pipelineUrl = pipelineUrl;
 
-    writeInitConfig(opts.cwd, opts);
-
     console.log("\n  Stack : " + stack);
     console.log("  Tools : " + (tools.join(", ") || "none"));
+    console.log("  Docs Language: " + opts.docsLanguage);
+    console.log("  Workflow Mode: " + opts.workflowMode);
     console.log("  Share Tickets: " + (opts.shareTickets ? "Yes (Shared)" : "No (Private)"));
     console.log("  Remote Sync:   " + (opts.remoteSync ? "Enabled" : "Disabled"));
     if (opts.remoteSync) console.log("  Pipeline URL:  " + opts.pipelineUrl);

package/scripts/cli-rule-compiler.mjs

@@ -8,8 +8,8 @@ import YAML from "yaml";
  * and compiles a single rule string for injection.
  */
 export function compileDynamicRules(cwd, bundleRoot, targetFileName) {
-  const bundleRulesDir = join(bundleRoot, "rules.d");
-  const localRulesDir = join(cwd, AGENT_ROOT_DIR, "domain-rules");
+  const bundleRulesDir = join(bundleRoot, "templates", "rules.d");
+  const localRulesDir = join(cwd, AGENT_ROOT_DIR, "project-rules");
   
   const allRuleFiles = [];
   
@@ -30,24 +30,29 @@ export function compileDynamicRules(cwd, bundleRoot, targetFileName) {
   let compiledContent = "";
 
   for (const filePath of allRuleFiles) {
-    const rawContent = readFileSync(filePath, "utf8");
-    const { meta, content } = parseFrontMatter(rawContent);
-    
-    // Check if this rule is intended for the current target file (e.g., AGENTS.md)
-    if (meta.inject_target && !meta.inject_target.includes(targetFileName)) {
-      continue;
-    }
+    try {
+      const rawContent = readFileSync(filePath, "utf8");
+      const { meta, content } = parseFrontMatter(rawContent);
+      
+      // Check if this rule is intended for the current target file (e.g., AGENTS.md)
+      if (meta.inject_target && !meta.inject_target.includes(targetFileName)) {
+        continue;
+      }
 
-    // Evaluate conditions
-    let shouldInclude = true;
-    if (meta.condition) {
-      shouldInclude = evaluateCondition(meta.condition, cwd);
-    }
-    
-    if (shouldInclude) {
-      const sourceId = meta.id || basename(filePath);
-      compiledContent += `\n<!-- RULE MODULE: ${sourceId} -->\n`;
-      compiledContent += content.trim() + "\n";
+      // Evaluate conditions
+      let shouldInclude = true;
+      if (meta.condition) {
+        shouldInclude = evaluateCondition(meta.condition, cwd);
+      }
+      
+      if (shouldInclude) {
+        const sourceId = meta.id || basename(filePath);
+        compiledContent += `\n<!-- RULE MODULE: ${sourceId} -->\n`;
+        compiledContent += content.trim() + "\n";
+      }
+    } catch (err) {
+      console.warn(`[WARNING] Skipping malformed rule file at ${filePath}:`, err.message);
+      continue;
     }
   }
 
@@ -55,20 +60,25 @@ export function compileDynamicRules(cwd, bundleRoot, targetFileName) {
 }
 
 /**
- * Attempts to locate and parse the DeukRag config.yaml from the workspace root.
+ * Attempts to locate and parse the DeukContext config.yaml from the workspace root.
  */
-function resolveDeukRagConfig(cwd) {
-  // Go up directories until we find a sibling DeukRag folder, or hit root
+function resolveDeukContextConfig(cwd) {
+  // Go up directories until we find a sibling DeukAgentContext folder, or hit root
   let current = resolve(cwd);
   while (current && current !== "/") {
-    const candidatePath = join(current, "DeukRag", ".local", "config.yaml");
-    if (existsSync(candidatePath)) {
-      try {
-        const raw = readFileSync(candidatePath, "utf8");
-        return YAML.parse(raw);
-      } catch (e) {
-        console.error("Failed to parse DeukRag config.yaml:", e);
-        return null;
+    const candidates = [
+      join(current, "DeukAgentContext", ".local", "config.yaml"),
+      join(current, "DeukContext", ".local", "config.yaml") // Legacy fallback
+    ];
+    for (const candidatePath of candidates) {
+      if (existsSync(candidatePath)) {
+        try {
+          const raw = readFileSync(candidatePath, "utf8");
+          return YAML.parse(raw);
+        } catch (e) {
+          console.error("Failed to parse DeukContext config.yaml:", e);
+          return null;
+        }
       }
     }
     const parent = dirname(current);
@@ -84,12 +94,12 @@ function resolveDeukRagConfig(cwd) {
 function evaluateCondition(condition, cwd) {
   if (!condition) return true;
 
-  // Example: condition: { mcp: "deukrag" }
-  if (condition.mcp === "deukrag") {
-    const ragConfig = resolveDeukRagConfig(cwd);
+  // Example: condition: { mcp: "deuk-agent-context" }
+  if (condition.mcp === "deuk-agent-context" || condition.mcp === "deuk_agent_context") {
+    const ragConfig = resolveDeukContextConfig(cwd);
     if (!ragConfig || !ragConfig.projects) return false;
 
-    // Check if the current cwd is managed by DeukRag
+    // Check if the current cwd is managed by DeukContext
     const isManaged = ragConfig.projects.some(p => {
       // If the project path is a prefix of cwd, it's managed
       return cwd.startsWith(p.path);

package/scripts/cli-skill-commands.mjs

@@ -0,0 +1,172 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { AGENT_ROOT_DIR } from "./cli-utils.mjs";
+
+const SKILL_IDS = ["safe-refactor", "generated-file-guard", "context-recall"];
+const SKILL_ROOT = "templates/skills";
+const CONFIG_FILE = `${AGENT_ROOT_DIR}/skills.json`;
+const REPO_SKILL_TEMPLATE_ROOT = `${AGENT_ROOT_DIR}/skill-templates`;
+
+function repoSkillPath(cwd, id) {
+  return join(cwd, AGENT_ROOT_DIR, "skills", id, "SKILL.md");
+}
+
+function sourceSkillPath(cwd, id) {
+  const localTemplate = join(cwd, REPO_SKILL_TEMPLATE_ROOT, id, "SKILL.md");
+  if (existsSync(localTemplate)) return localTemplate;
+  return join(cwd, SKILL_ROOT, id, "SKILL.md");
+}
+
+function loadSkillSource(cwd, id) {
+  const source = sourceSkillPath(cwd, id);
+  if (!existsSync(source)) throw new Error(`skill not found: ${id}`);
+  return readFileSync(source, "utf8");
+}
+
+function loadSkillConfig(cwd) {
+  const path = join(cwd, CONFIG_FILE);
+  if (!existsSync(path)) return { version: 1, installed: [], exposed: {} };
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+
+function writeSkillConfig(cwd, config, dryRun) {
+  if (dryRun) return;
+  const path = join(cwd, CONFIG_FILE);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(config, null, 2), "utf8");
+}
+
+function ensureKnownSkill(id) {
+  if (!SKILL_IDS.includes(id)) throw new Error(`unknown skill: ${id}`);
+}
+
+export function listSkills(cwd = process.cwd()) {
+  const config = loadSkillConfig(cwd);
+  return SKILL_IDS.map(id => ({
+    id,
+    installed: config.installed.includes(id),
+    exposed: Object.entries(config.exposed || {})
+      .filter(([, ids]) => Array.isArray(ids) && ids.includes(id))
+      .map(([platform]) => platform)
+  }));
+}
+
+export function addSkill(opts = {}) {
+  const cwd = opts.cwd || process.cwd();
+  const id = opts.skill;
+  ensureKnownSkill(id);
+  const body = loadSkillSource(cwd, id);
+  const target = repoSkillPath(cwd, id);
+  const config = loadSkillConfig(cwd);
+
+  if (!opts.dryRun) {
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, body, "utf8");
+  }
+
+  if (!config.installed.includes(id)) config.installed.push(id);
+  writeSkillConfig(cwd, config, opts.dryRun);
+  return { id, target };
+}
+
+function exposeClaude(cwd, ids, dryRun) {
+  for (const id of ids) {
+    const body = readFileSync(repoSkillPath(cwd, id), "utf8");
+    const target = join(cwd, ".claude", "skills", id, "SKILL.md");
+    if (!dryRun) {
+      mkdirSync(dirname(target), { recursive: true });
+      writeFileSync(target, body, "utf8");
+    }
+  }
+}
+
+function exposeCursor(cwd, ids, dryRun) {
+  const target = join(cwd, ".cursor", "rules", "deuk-agent-skills.mdc");
+  const body = [
+    "---",
+    "description: \"DeukAgentRules skill pointers\"",
+    "globs: [\"**/*\"]",
+    "alwaysApply: false",
+    "---",
+    "# DeukAgentRules Skills",
+    "",
+    "These are thin behavior playbooks. They do not override `core-rules/AGENTS.md`, TDW, APC, Phase Gate, or PROJECT_RULE.md.",
+    "",
+    ...ids.map(id => `- ${id}: .deuk-agent/skills/${id}/SKILL.md`),
+    ""
+  ].join("\n");
+  if (!dryRun) {
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, body, "utf8");
+  }
+}
+
+export function exposeSkills(opts = {}) {
+  const cwd = opts.cwd || process.cwd();
+  const platform = String(opts.platform || "").toLowerCase();
+  if (!["claude", "cursor"].includes(platform)) throw new Error("skill expose requires --platform claude|cursor");
+
+  const config = loadSkillConfig(cwd);
+  const ids = config.installed || [];
+  if (ids.length === 0) throw new Error("no skills installed; run skill add first");
+  for (const id of ids) {
+    if (!existsSync(repoSkillPath(cwd, id))) addSkill({ cwd, skill: id, dryRun: opts.dryRun });
+  }
+
+  if (platform === "claude") exposeClaude(cwd, ids, opts.dryRun);
+  if (platform === "cursor") exposeCursor(cwd, ids, opts.dryRun);
+
+  config.exposed = config.exposed || {};
+  config.exposed[platform] = Array.from(new Set([...(config.exposed[platform] || []), ...ids]));
+  writeSkillConfig(cwd, config, opts.dryRun);
+  return { platform, ids };
+}
+
+export function lintSkills(cwd = process.cwd()) {
+  const paths = [];
+  for (const root of [join(cwd, SKILL_ROOT), join(cwd, REPO_SKILL_TEMPLATE_ROOT), join(cwd, AGENT_ROOT_DIR, "skills")]) {
+    if (!existsSync(root)) continue;
+    for (const id of readdirSync(root)) {
+      const path = join(root, id, "SKILL.md");
+      if (existsSync(path)) paths.push(path);
+    }
+  }
+
+  const violations = [];
+  const forbidden = [/ignore ticket/i, /skip verification/i, /override (tdw|apc|phase gate)/i, /edit generated output directly/i];
+  for (const path of paths) {
+    const body = readFileSync(path, "utf8");
+    if (!/Authority:.*core-rules\/AGENTS\.md/i.test(body)) violations.push(`${path}: missing authority line`);
+    for (const pattern of forbidden) {
+      if (pattern.test(body)) violations.push(`${path}: forbidden phrase ${pattern}`);
+    }
+  }
+  return { ok: violations.length === 0, paths, violations };
+}
+
+export async function runSkill(action, opts = {}) {
+  if (action === "list") {
+    const rows = listSkills(opts.cwd);
+    if (opts.json) console.log(JSON.stringify(rows, null, 2));
+    else rows.forEach(row => console.log(`${row.id} installed=${row.installed ? "yes" : "no"} exposed=${row.exposed.join(",") || "-"}`));
+    return;
+  }
+  if (action === "add") {
+    const result = addSkill(opts);
+    console.log(`skill added: ${result.id}`);
+    return;
+  }
+  if (action === "expose") {
+    const result = exposeSkills(opts);
+    console.log(`skills exposed: ${result.platform} ${result.ids.join(",")}`);
+    return;
+  }
+  if (action === "lint") {
+    const result = lintSkills(opts.cwd);
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+    else console.log(result.ok ? "skill:lint ok" : `skill:lint failed ${result.violations.length}`);
+    if (!result.ok) throw new Error(result.violations.join("\n"));
+    return;
+  }
+  throw new Error("Unknown skill action: " + action);
+}