deuk-agent-flow 4.0.19

package/scripts/cli-init-logic.mjs

@@ -0,0 +1,64 @@
+import { existsSync, appendFileSync, writeFileSync, mkdirSync, readFileSync } from "fs";
+import { join } from "path";
+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-flow: agent hub directory (local, not committed by default)";
+const LEGACY_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");
+  const ignoreLine = AGENT_ROOT_DIR + "/";
+
+  if (opts.dryRun) return;
+
+  mkdirSync(ticketPath, { recursive: true });
+  if (opts.shareTickets) {
+    console.log(`[INIT] Ticket sharing enabled. Skipping .gitignore entry for ${AGENT_ROOT_DIR}/`);
+    return;
+  }
+
+  let gi = existsSync(gitignorePath) ? readFileSync(gitignorePath, "utf8") : "";
+  
+  // 1. Create document directories
+  const docsPath = join(opts.cwd, AGENT_ROOT_DIR, "docs");
+  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 = `${LEGACY_TICKET_DIR}/`;
+  const legacyIgnore2 = `${LEGACY_TICKET_DIR_PLURAL}/`;
+  const legacyIgnore3 = LEGACY_IGNORE_DIR;
+  const cleanedGi = removeExactGitignoreLines(gi, [legacyIgnore1, legacyIgnore2, legacyIgnore3, LEGACY_GITIGNORE_AGENT_MARKER]);
+  if (cleanedGi !== gi) {
+    writeFileSync(gitignorePath, cleanedGi.replace(/\n*$/, "\n"), "utf8");
+    gi = cleanedGi;
+    console.log("[INIT] Removed legacy deuk-agent-rule .gitignore entries");
+  }
+
+  const hasIgnoreLine = hasExactGitignoreLine(gi, ignoreLine);
+  const hasMarkerLine = hasExactGitignoreLine(gi, GITIGNORE_AGENT_MARKER);
+  if ((!hasIgnoreLine || !hasMarkerLine) && !opts.shareTickets) {
+    const linesToAdd = [];
+    if (!hasMarkerLine) linesToAdd.push(GITIGNORE_AGENT_MARKER);
+    if (!hasIgnoreLine) linesToAdd.push(ignoreLine);
+    const block = "\n" + linesToAdd.join("\n") + "\n";
+    appendFileSync(gitignorePath, block, "utf8");
+    console.log(`[INIT] Added ${ignoreLine} to .gitignore`);
+  }
+}

package/scripts/cli-prompts.mjs

@@ -0,0 +1,104 @@
+import { createInterface } from "readline";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+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));
+}
+
+export async function askYesNo(question, defaultYes = true) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const ans = (await ask(rl, question + (defaultYes ? " [Y/n]: " : " [y/N]: "))).trim().toLowerCase();
+    if (!ans) return defaultYes;
+    return ans === "y" || ans === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
+export async function selectOne(rl, prompt, choices) {
+  console.log("\n" + prompt);
+  choices.forEach((c, i) => console.log(`  ${i + 1}) ${c.label}`));
+  while (true) {
+    const ans = (await ask(rl, `  Choice [1-${choices.length}]: `)).trim();
+    const idx = parseInt(ans, 10) - 1;
+    if (idx >= 0 && idx < choices.length) return choices[idx].value;
+  }
+}
+
+export async function selectMany(rl, prompt, choices) {
+  console.log("\n" + prompt + " (comma-separated numbers, or 'all')");
+  choices.forEach((c, i) => console.log(`  ${i + 1}) ${c.label}`));
+  while (true) {
+    const ans = (await ask(rl, `  Choices: `)).trim().toLowerCase();
+    if (ans === "all" || ans === "") return choices.map((c) => c.value);
+    const parts = ans.split(/[,\s]+/).map((s) => parseInt(s, 10) - 1);
+    if (parts.every((i) => i >= 0 && i < choices.length)) return parts.map((i) => choices[i].value);
+  }
+}
+
+
+
+export async function runInteractive(opts) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    console.log("\nDeukAgentFlow init — let's configure your workspace.\n");
+
+    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");
+    let agentsDefault = "inject";
+    if (!existsSync(targetAgents)) {
+      agentsDefault = "inject"; // will append markers
+      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") || content.includes("## DeukAgentFlow");
+      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" },
+          { label: "Overwrite entire AGENTS.md", value: "overwrite" },
+          { label: "Skip AGENTS.md", value: "skip" },
+        ]);
+        agentsDefault = choice;
+      }
+    }
+
+    const remoteSync = opts.remoteSync !== undefined ? opts.remoteSync : (await askYesNo("Enable AI Pipeline remote synchronization? (Advanced)", false));
+    let pipelineUrl = opts.pipelineUrl || "";
+    if (remoteSync && !pipelineUrl) {
+      pipelineUrl = (await ask(rl, "Enter AI Pipeline Endpoint URL: ")).trim();
+    }
+
+    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;
+
+    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);
+    console.log("  AGENTS: " + opts.agents + "\n");
+  } finally {
+    rl.close();
+  }
+}

package/scripts/cli-rule-compiler.mjs

@@ -0,0 +1,112 @@
+import { join, basename, resolve, dirname } from "path";
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { parseFrontMatter, AGENT_ROOT_DIR } from "./cli-utils.mjs";
+import YAML from "yaml";
+
+/**
+ * Scans directories for rule markdown files, evaluates their Frontmatter conditions,
+ * and compiles a single rule string for injection.
+ */
+export function compileDynamicRules(cwd, bundleRoot, targetFileName) {
+  const bundleRulesDir = join(bundleRoot, "templates", "rules.d");
+  const localRulesDir = join(cwd, AGENT_ROOT_DIR, "project-rules");
+  
+  const allRuleFiles = [];
+  
+  // 1. Gather global rules
+  if (existsSync(bundleRulesDir)) {
+    readdirSync(bundleRulesDir).forEach(f => {
+      if (f.endsWith(".md")) allRuleFiles.push(join(bundleRulesDir, f));
+    });
+  }
+  
+  // 2. Gather local domain rules
+  if (existsSync(localRulesDir)) {
+    readdirSync(localRulesDir).forEach(f => {
+      if (f.endsWith(".md")) allRuleFiles.push(join(localRulesDir, f));
+    });
+  }
+
+  let compiledContent = "";
+
+  for (const filePath of allRuleFiles) {
+    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";
+      }
+    } catch (err) {
+      console.warn(`[WARNING] Skipping malformed rule file at ${filePath}:`, err.message);
+      continue;
+    }
+  }
+
+  return compiledContent.trim();
+}
+
+/**
+ * Attempts to locate and parse the DeukContext config.yaml from the workspace 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 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);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+
+/**
+ * Evaluates Frontmatter conditions to determine if a rule should be included.
+ */
+function evaluateCondition(condition, cwd) {
+  if (!condition) return true;
+
+  // 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 DeukContext
+    const isManaged = ragConfig.projects.some(p => {
+      // If the project path is a prefix of cwd, it's managed
+      return cwd.startsWith(p.path);
+    });
+    
+    return isManaged;
+  }
+
+  return true;
+}

package/scripts/cli-skill-commands.mjs

@@ -0,0 +1,201 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { AGENT_ROOT_DIR } from "./cli-utils.mjs";
+
+const SKILL_IDS = ["safe-refactor", "generated-file-guard", "context-recall", "project-pilot"];
+const SKILL_ROOT = "templates/skills";
+const CONFIG_FILE = `${AGENT_ROOT_DIR}/skills.json`;
+const REPO_SKILL_TEMPLATE_ROOT = `${AGENT_ROOT_DIR}/skill-templates`;
+const PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+
+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;
+  const repoTemplate = join(cwd, SKILL_ROOT, id, "SKILL.md");
+  if (existsSync(repoTemplate)) return repoTemplate;
+  return join(PACKAGE_ROOT, 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 detectExposedPlatforms(cwd, id) {
+  const platforms = [];
+  const claudePath = join(cwd, ".claude", "skills", id, "SKILL.md");
+  if (existsSync(claudePath)) {
+    platforms.push("claude");
+  }
+
+  const cursorPath = join(cwd, ".cursor", "rules", "deuk-agent-skills.mdc");
+  if (existsSync(cursorPath)) {
+    try {
+      const body = readFileSync(cursorPath, "utf8");
+      if (body.includes(`.deuk-agent/skills/${id}/SKILL.md`)) {
+        platforms.push("cursor");
+      }
+    } catch {
+      // Ignore pointer read failures and fall back to config-based exposure only.
+    }
+  }
+
+  return platforms;
+}
+
+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) || existsSync(repoSkillPath(cwd, id)),
+    exposed: Array.from(new Set([
+      ...Object.entries(config.exposed || {})
+      .filter(([, ids]) => Array.isArray(ids) && ids.includes(id))
+      .map(([platform]) => platform),
+      ...detectExposedPlatforms(cwd, id)
+    ]))
+  }));
+}
+
+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: \"DeukAgentFlow skill pointers\"",
+    "globs: [\"**/*\"]",
+    "alwaysApply: false",
+    "---",
+    "# DeukAgentFlow 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);
+}