@k0t0vich/meta-agents-template 0.1.3 → 0.1.4

package/template/.meta-agents/scripts/task-branch-router.mjs

@@ -0,0 +1,530 @@
+import { execFileSync } from "node:child_process";
+import process from "node:process";
+
+const BRANCH_PATTERNS = [
+  { type: "main", regex: /^main$/ },
+  { type: "develop", regex: /^develop$/ },
+  { type: "feature", regex: /^feature\/.+/ },
+  { type: "release", regex: /^release\/.+/ },
+  { type: "hotfix", regex: /^hotfix\/.+/ },
+  { type: "feature", regex: /^codex\/feature\/.+/ },
+  { type: "release", regex: /^codex\/release\/.+/ },
+  { type: "hotfix", regex: /^codex\/hotfix\/.+/ },
+];
+
+const TASK_KIND_MAP = {
+  atomic: "feature",
+  feature: "feature",
+  release: "release",
+  hotfix: "hotfix",
+};
+
+function git(args, allowFailure = false) {
+  try {
+    return execFileSync("git", args, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      cwd: process.cwd(),
+    }).trim();
+  } catch (error) {
+    if (allowFailure) {
+      return "";
+    }
+    throw error;
+  }
+}
+
+function parseArgs(argv) {
+  const options = {
+    task: "",
+    slug: "",
+    kind: "atomic",
+    base: "",
+    apply: false,
+    allowDirty: false,
+    allowAhead: false,
+    json: false,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--task") {
+      options.task = (argv[i + 1] || "").trim();
+      i += 1;
+      continue;
+    }
+    if (arg === "--slug") {
+      options.slug = (argv[i + 1] || "").trim();
+      i += 1;
+      continue;
+    }
+    if (arg === "--kind") {
+      options.kind = (argv[i + 1] || "").trim().toLowerCase();
+      i += 1;
+      continue;
+    }
+    if (arg === "--base") {
+      options.base = (argv[i + 1] || "").trim();
+      i += 1;
+      continue;
+    }
+    if (arg === "--apply") {
+      options.apply = true;
+      continue;
+    }
+    if (arg === "--allow-dirty") {
+      options.allowDirty = true;
+      continue;
+    }
+    if (arg === "--allow-ahead") {
+      options.allowAhead = true;
+      continue;
+    }
+    if (arg === "--json") {
+      options.json = true;
+      continue;
+    }
+  }
+
+  return options;
+}
+
+function detectBranch() {
+  const direct = git(["rev-parse", "--abbrev-ref", "HEAD"], true);
+  if (direct && direct !== "HEAD") {
+    return direct;
+  }
+
+  const status = git(["status", "--short", "--branch"], true);
+  const header = status.split("\n")[0] || "";
+
+  const noCommitsMatch = header.match(/^##\s+No commits yet on\s+(.+)$/);
+  if (noCommitsMatch) {
+    return noCommitsMatch[1].trim();
+  }
+
+  const branchMatch = header.match(/^##\s+([^\.\s]+)(?:\.\.\.[^\s]+)?/);
+  if (branchMatch) {
+    return branchMatch[1].trim();
+  }
+
+  return "";
+}
+
+function classifyBranch(branch) {
+  const source = String(branch || "").trim();
+  for (const pattern of BRANCH_PATTERNS) {
+    if (pattern.regex.test(source)) {
+      return pattern.type;
+    }
+  }
+  return "unknown";
+}
+
+function parseBranchHeader(header) {
+  const result = {
+    upstream: "",
+    ahead: 0,
+    behind: 0,
+  };
+
+  const match = header.match(/^##\s+[^\.\s]+(?:\.\.\.([^\s]+))?(?:\s+\[(.+)\])?/);
+  if (!match) {
+    return result;
+  }
+
+  result.upstream = match[1] || "";
+  const details = match[2] || "";
+  const aheadMatch = details.match(/ahead\s+(\d+)/);
+  const behindMatch = details.match(/behind\s+(\d+)/);
+  result.ahead = aheadMatch ? Number(aheadMatch[1]) : 0;
+  result.behind = behindMatch ? Number(behindMatch[1]) : 0;
+  return result;
+}
+
+function collectGitContext() {
+  const raw = git(["status", "--short", "--branch"], true);
+  const lines = raw ? raw.split("\n").filter(Boolean) : [];
+  const header = lines[0] || "";
+  const files = lines.slice(1);
+  const parsed = parseBranchHeader(header);
+
+  let modifiedOrStaged = 0;
+  let untracked = 0;
+  for (const line of files) {
+    const status = line.slice(0, 2).trim();
+    if (status === "??") {
+      untracked += 1;
+    } else {
+      modifiedOrStaged += 1;
+    }
+  }
+
+  const branch = detectBranch() || "unknown";
+  return {
+    branch,
+    branchType: classifyBranch(branch),
+    branchTaskRef: extractBranchTaskRef(branch),
+    upstream: parsed.upstream || "not configured",
+    ahead: parsed.ahead,
+    behind: parsed.behind,
+    modifiedOrStaged,
+    untracked,
+    dirty: modifiedOrStaged > 0 || untracked > 0,
+  };
+}
+
+function extractBranchTaskRef(branch) {
+  const source = String(branch || "").trim();
+  if (!source) {
+    return "";
+  }
+
+  const normalized = source.startsWith("codex/") ? source.slice("codex/".length) : source;
+  const match = normalized.match(/^(feature|release|hotfix)\/(.+)$/);
+  if (!match) {
+    return "";
+  }
+
+  const tail = match[2];
+  const taskMatch = tail.match(/^([A-Za-z][A-Za-z0-9_]*-\d+)/);
+  if (taskMatch) {
+    return taskMatch[1].toUpperCase();
+  }
+
+  const issueMatch = tail.match(/^(\d+)(?:-|$)/);
+  if (issueMatch) {
+    return issueMatch[1];
+  }
+
+  return "";
+}
+
+function normalizeTaskRef(task) {
+  const source = String(task || "").trim();
+  if (!source) {
+    return "";
+  }
+
+  const issue = source.match(/^#?(\d+)$/);
+  if (issue) {
+    return issue[1];
+  }
+
+  const fromBodyIssue = source.match(/#(\d+)/);
+  if (fromBodyIssue) {
+    return fromBodyIssue[1];
+  }
+
+  const taskRef = source.match(/([A-Za-z][A-Za-z0-9_]*-\d+)/);
+  if (taskRef) {
+    return taskRef[1].toUpperCase();
+  }
+
+  return source.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+}
+
+function slugify(value) {
+  return String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+function normalizeKind(kind) {
+  const normalized = TASK_KIND_MAP[kind];
+  if (!normalized) {
+    throw new Error("unsupported --kind. Allowed: atomic, feature, release, hotfix");
+  }
+  return normalized;
+}
+
+function defaultBaseBranch(kind) {
+  if (kind === "hotfix") {
+    return "main";
+  }
+  return "develop";
+}
+
+function buildTargetBranch({ kind, taskRef, slug }) {
+  const prefix = `codex/${kind}`;
+  const taskPart = slugify(taskRef) || "task";
+  const slugPart = slugify(slug) || "work";
+  if (slugPart === taskPart) {
+    return `${prefix}/${taskPart}`;
+  }
+  return `${prefix}/${taskPart}-${slugPart}`;
+}
+
+function hasRef(ref) {
+  return Boolean(git(["show-ref", "--verify", ref], true));
+}
+
+function hasOrigin() {
+  return Boolean(git(["remote", "get-url", "origin"], true));
+}
+
+function readFileAtRef(ref, filePath) {
+  return git(["show", `${ref}:${filePath}`], true);
+}
+
+function getContextWarnings(baseBranch) {
+  const warnings = [];
+  if (!baseBranch) {
+    return warnings;
+  }
+
+  const baseExists = hasRef(`refs/heads/${baseBranch}`) || hasRef(`refs/remotes/origin/${baseBranch}`);
+  if (!baseExists) {
+    warnings.push(
+      `Cannot compare governance context: base branch '${baseBranch}' is not available locally/remotely.`,
+    );
+    return warnings;
+  }
+
+  const currentAgents = readFileAtRef("HEAD", "agents.md");
+  const baseAgents = readFileAtRef(baseBranch, "agents.md");
+
+  if (!currentAgents || !baseAgents) {
+    warnings.push(
+      "Cannot compare governance context file 'agents.md' between current and base branch (missing in one of refs).",
+    );
+    return warnings;
+  }
+
+  if (currentAgents !== baseAgents) {
+    warnings.push(
+      `Governance context differs: 'agents.md' in current branch is not equal to '${baseBranch}:agents.md'. Confirm switch before apply.`,
+    );
+  }
+
+  return warnings;
+}
+
+function executePlan(plan, gitContext) {
+  if (plan.decision === "stay_on_current_branch") {
+    return {
+      changedBranch: false,
+      branch: gitContext.branch,
+      message: "Task is related to current feature branch. Stay in place.",
+    };
+  }
+
+  if (plan.blockers.length > 0) {
+    throw new Error(`cannot apply route because blockers exist: ${plan.blockers.join("; ")}`);
+  }
+
+  if (hasRef(`refs/heads/${plan.targetBranch}`) || hasRef(`refs/remotes/origin/${plan.targetBranch}`)) {
+    throw new Error(`target branch '${plan.targetBranch}' already exists`);
+  }
+
+  const baseBranch = plan.requested.baseBranch;
+  const originExists = hasOrigin();
+  if (originExists) {
+    git(["fetch", "origin"], false);
+  }
+
+  const baseLocal = hasRef(`refs/heads/${baseBranch}`);
+  const baseRemote = hasRef(`refs/remotes/origin/${baseBranch}`);
+
+  if (!baseLocal && !baseRemote) {
+    throw new Error(
+      `base branch '${baseBranch}' not found locally or on origin. Create/sync it first.`,
+    );
+  }
+
+  if (baseLocal) {
+    git(["checkout", baseBranch], false);
+  } else {
+    git(["checkout", "-b", baseBranch, "--track", `origin/${baseBranch}`], false);
+  }
+
+  if (originExists && baseRemote) {
+    git(["pull", "--ff-only", "origin", baseBranch], false);
+  }
+
+  git(["checkout", "-b", plan.targetBranch], false);
+
+  return {
+    changedBranch: true,
+    branch: plan.targetBranch,
+    message: `Created and checked out '${plan.targetBranch}' from '${baseBranch}'.`,
+  };
+}
+
+function buildPlan(options, gitContext) {
+  if (!options.task) {
+    throw new Error("missing --task");
+  }
+
+  const kind = normalizeKind(options.kind);
+  const taskRef = normalizeTaskRef(options.task);
+  const sameFeature =
+    kind === "feature" &&
+    gitContext.branchType === "feature" &&
+    Boolean(taskRef) &&
+    taskRef === gitContext.branchTaskRef;
+
+  const baseBranch = options.base || defaultBaseBranch(kind);
+  const targetBranch = sameFeature
+    ? gitContext.branch
+    : buildTargetBranch({
+        kind,
+        taskRef,
+        slug: options.slug || options.task,
+      });
+
+  const blockers = [];
+  const requiresDialogue = [];
+
+  if (!sameFeature && gitContext.dirty && !options.allowDirty) {
+    blockers.push("working_tree_dirty");
+    requiresDialogue.push(
+      "Есть незакоммиченные изменения. Нужен выбор: commit/stash/discard перед переключением ветки.",
+    );
+  }
+
+  if (!sameFeature && gitContext.ahead > 0 && !options.allowAhead) {
+    blockers.push("current_branch_ahead");
+    requiresDialogue.push(
+      "В текущей ветке есть непушенные коммиты (ahead > 0). Нужна явная фиксация решения перед переключением.",
+    );
+  }
+
+  if (sameFeature) {
+    requiresDialogue.push(
+      "Задача атомарная и относится к текущей feature-ветке. Подтвердите, что продолжаем работу в этой ветке.",
+    );
+  } else {
+    requiresDialogue.push(
+      "Задача не относится к текущей ветке. Подтвердите переключение на базовую ветку, обновление и создание новой рабочей ветки.",
+    );
+  }
+
+  return {
+    requested: {
+      task: options.task,
+      taskRef,
+      kind,
+      baseBranch,
+    },
+    decision: sameFeature ? "stay_on_current_branch" : "create_new_branch",
+    current: gitContext,
+    targetBranch,
+    blockers,
+    contextWarnings: getContextWarnings(baseBranch),
+    requiresDialogue,
+    suggestedCommands: sameFeature
+      ? []
+      : [
+          "git fetch origin",
+          `git checkout ${baseBranch}`,
+          `git pull --ff-only origin ${baseBranch}`,
+          `git checkout -b ${targetBranch}`,
+        ],
+  };
+}
+
+function printPlan(plan, applyResult) {
+  console.log("# Task Branch Routing");
+  console.log("");
+  console.log("## Current Git Context");
+  console.log(`- branch: ${plan.current.branch}`);
+  console.log(`- branch type: ${plan.current.branchType}`);
+  console.log(`- branch task ref: ${plan.current.branchTaskRef || "not detected"}`);
+  console.log(`- upstream: ${plan.current.upstream}`);
+  console.log(`- ahead/behind: ${plan.current.ahead}/${plan.current.behind}`);
+  console.log(`- modified_or_staged: ${plan.current.modifiedOrStaged}`);
+  console.log(`- untracked: ${plan.current.untracked}`);
+
+  console.log("");
+  console.log("## Requested Task");
+  console.log(`- task: ${plan.requested.task}`);
+  console.log(`- normalized task ref: ${plan.requested.taskRef || "not detected"}`);
+  console.log(`- kind: ${plan.requested.kind}`);
+  console.log(`- base branch: ${plan.requested.baseBranch}`);
+
+  console.log("");
+  console.log("## Decision");
+  console.log(`- route: ${plan.decision}`);
+  console.log(`- target branch: ${plan.targetBranch}`);
+  if (plan.blockers.length === 0) {
+    console.log("- blockers: none");
+  } else {
+    console.log(`- blockers: ${plan.blockers.join(", ")}`);
+  }
+
+  console.log("");
+  console.log("## Context Warnings");
+  if (plan.contextWarnings.length === 0) {
+    console.log("- none");
+  } else {
+    for (const warning of plan.contextWarnings) {
+      console.log(`- ${warning}`);
+    }
+  }
+
+  console.log("");
+  console.log("## Required User Dialogue");
+  for (const line of plan.requiresDialogue) {
+    console.log(`- ${line}`);
+  }
+
+  console.log("");
+  console.log("## Suggested Commands");
+  if (plan.suggestedCommands.length === 0) {
+    console.log("- no branch switch required");
+  } else {
+    for (const cmd of plan.suggestedCommands) {
+      console.log(`- ${cmd}`);
+    }
+  }
+
+  if (applyResult) {
+    console.log("");
+    console.log("## Apply Result");
+    console.log(`- changed branch: ${applyResult.changedBranch ? "yes" : "no"}`);
+    console.log(`- active branch: ${applyResult.branch}`);
+    console.log(`- message: ${applyResult.message}`);
+  } else {
+    console.log("");
+    console.log("## Apply");
+    console.log("- preview mode only. Re-run with --apply after user confirmation.");
+  }
+}
+
+function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const gitContext = collectGitContext();
+  const plan = buildPlan(options, gitContext);
+
+  let applyResult = null;
+  if (options.apply) {
+    applyResult = executePlan(plan, gitContext);
+  }
+
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          ...plan,
+          applyResult,
+        },
+        null,
+        2,
+      ),
+    );
+    return;
+  }
+
+  printPlan(plan, applyResult);
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(`task-branch-router FAIL: ${error.message}`);
+  process.exit(1);
+}

package/template/.meta-agents/scripts/tracker/provider-lock.mjs

@@ -0,0 +1,104 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const ALLOWED_TRACKERS = new Set(["github", "mcp", "local", "custom"]);
+
+function normalizeTracker(value) {
+  if (!value) {
+    return "";
+  }
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized === "mpc") {
+    return "mcp";
+  }
+  return normalized;
+}
+
+function isPlaceholder(value) {
+  return /^__[^_].*__$/.test(value);
+}
+
+function parseTrackersDefault(content) {
+  const match = content.match(/^\s*default:\s*"?([a-zA-Z0-9_-]+)"?\s*$/m);
+  return normalizeTracker(match?.[1] || "");
+}
+
+function parseProjectSelected(content) {
+  const match = content.match(/^\s*selected:\s*"?([a-zA-Z0-9_-]+)"?\s*$/m);
+  return normalizeTracker(match?.[1] || "");
+}
+
+function readTextOrEmpty(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+export function resolveLockedTrackerProvider(cwd = process.cwd()) {
+  const configDir = path.resolve(cwd, ".meta-agents", "config");
+  const trackersPath = path.join(configDir, "trackers.yaml");
+  const projectContextPath = path.join(configDir, "project-context.yaml");
+
+  const trackersYaml = readTextOrEmpty(trackersPath);
+  const projectContextYaml = readTextOrEmpty(projectContextPath);
+
+  const errors = [];
+  if (!trackersYaml) {
+    errors.push("missing .meta-agents/config/trackers.yaml");
+  }
+  if (!projectContextYaml) {
+    errors.push("missing .meta-agents/config/project-context.yaml");
+  }
+
+  const trackerDefault = parseTrackersDefault(trackersYaml);
+  const projectSelected = parseProjectSelected(projectContextYaml);
+
+  if (!trackerDefault) {
+    errors.push("trackers.yaml must define tracker_gateway.default");
+  }
+  if (!projectSelected) {
+    errors.push("project-context.yaml must define project_context.tracker_provider.selected");
+  }
+
+  if (trackerDefault && isPlaceholder(trackerDefault)) {
+    errors.push("trackers.yaml has unresolved placeholder in tracker_gateway.default");
+  }
+  if (projectSelected && isPlaceholder(projectSelected)) {
+    errors.push("project-context.yaml has unresolved placeholder in tracker_provider.selected");
+  }
+
+  if (trackerDefault && !ALLOWED_TRACKERS.has(trackerDefault)) {
+    errors.push(`unsupported tracker_gateway.default '${trackerDefault}'`);
+  }
+  if (projectSelected && !ALLOWED_TRACKERS.has(projectSelected)) {
+    errors.push(`unsupported tracker_provider.selected '${projectSelected}'`);
+  }
+
+  if (trackerDefault && projectSelected && trackerDefault !== projectSelected) {
+    errors.push(
+      `tracker mismatch: trackers.yaml default='${trackerDefault}' vs project-context selected='${projectSelected}'`,
+    );
+  }
+
+  if (errors.length > 0) {
+    throw new Error(`tracker provider lock FAIL: ${errors.join("; ")}`);
+  }
+
+  return trackerDefault || projectSelected;
+}
+
+export function resolveTrackerForCommand({ requestedTracker = "", cwd = process.cwd() } = {}) {
+  const lockedProvider = resolveLockedTrackerProvider(cwd);
+  const requested = normalizeTracker(requestedTracker);
+
+  if (requested && requested !== lockedProvider) {
+    throw new Error(
+      `tracker provider mismatch: requested='${requested}' but locked='${lockedProvider}'. ` +
+        "Update project-context.yaml and trackers.yaml together before switching tracker.",
+    );
+  }
+
+  return lockedProvider;
+}