@k0t0vich/meta-agents-template 0.1.2 → 0.1.4

package/template/.meta-agents/scripts/sync-status.mjs

@@ -1 +1,620 @@
-console.log("sync-status placeholder: connect to tracker and refresh local status views.");
+import fs from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { execFileSync } from "node:child_process";
+import { resolveTrackerForCommand } from "./tracker/provider-lock.mjs";
+
+const STATUS_LABELS = ["IN_PROGRESS", "REVIEW", "READY", "BLOCKED", "TODO", "DONE", "PUBLISH"];
+const EXCLUDED_TASK_FILES = new Set(["backlog.md", "task-status-log.md"]);
+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\/.+/ },
+];
+
+function parseArgs(argv) {
+  const options = {
+    tracker: "",
+    includeLocalCache: false,
+    json: false,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--tracker") {
+      options.tracker = (argv[i + 1] || "").trim().toLowerCase();
+      i += 1;
+      continue;
+    }
+    if (arg === "--include-local-cache") {
+      options.includeLocalCache = true;
+      continue;
+    }
+    if (arg === "--json") {
+      options.json = true;
+      continue;
+    }
+  }
+
+  return options;
+}
+
+function run(command, args, allowFailure = false) {
+  try {
+    return execFileSync(command, args, {
+      encoding: "utf8",
+      cwd: process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+  } catch (error) {
+    if (allowFailure) {
+      return "";
+    }
+    throw error;
+  }
+}
+
+function parseBranchHeader(header) {
+  // Example: "## main...origin/main [ahead 1]"
+  const result = {
+    branch: "unknown",
+    upstream: "",
+    ahead: 0,
+    behind: 0,
+  };
+
+  const noCommitsMatch = header.match(/^##\s+No commits yet on\s+(.+)$/);
+  if (noCommitsMatch) {
+    result.branch = noCommitsMatch[1].trim();
+    return result;
+  }
+
+  const match = header.match(/^##\s+([^\.\s]+)(?:\.\.\.([^\s]+))?(?:\s+\[(.+)\])?/);
+  if (!match) {
+    return result;
+  }
+
+  result.branch = match[1] || "unknown";
+  result.upstream = match[2] || "";
+
+  const aheadMatch = (match[3] || "").match(/ahead\s+(\d+)/);
+  const behindMatch = (match[3] || "").match(/behind\s+(\d+)/);
+  result.ahead = aheadMatch ? Number(aheadMatch[1]) : 0;
+  result.behind = behindMatch ? Number(behindMatch[1]) : 0;
+
+  return result;
+}
+
+function collectGitSummary() {
+  const raw = run("git", ["status", "--short", "--branch"], true);
+  if (!raw) {
+    return {
+      branch: "unknown",
+      branchType: "unknown",
+      branchTaskRef: "",
+      upstream: "",
+      ahead: 0,
+      behind: 0,
+      modifiedOrStaged: 0,
+      untracked: 0,
+      changedFiles: [],
+    };
+  }
+
+  const lines = raw.split("\n").filter(Boolean);
+  const header = lines[0] || "";
+  const files = lines.slice(1);
+  const parsed = parseBranchHeader(header);
+
+  let modifiedOrStaged = 0;
+  let untracked = 0;
+  const changedFiles = [];
+
+  for (const line of files) {
+    const status = line.slice(0, 2).trim();
+    const file = line.slice(3).trim();
+
+    if (status === "??") {
+      untracked += 1;
+    } else {
+      modifiedOrStaged += 1;
+    }
+
+    if (file) {
+      changedFiles.push(file);
+    }
+  }
+
+  return {
+    ...parsed,
+    branchType: classifyBranch(parsed.branch),
+    branchTaskRef: extractBranchTaskRef(parsed.branch),
+    modifiedOrStaged,
+    untracked,
+    changedFiles,
+  };
+}
+
+async function readTrackersConfig() {
+  const file = path.resolve(process.cwd(), ".meta-agents", "config", "trackers.yaml");
+  const content = await fs.readFile(file, "utf8");
+
+  const providers = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    const match = line.match(/^\s{4}([a-zA-Z0-9_-]+):\s*$/);
+    if (!match) {
+      continue;
+    }
+
+    const name = match[1];
+    if (name === "providers") {
+      continue;
+    }
+
+    const next = lines[i + 1] || "";
+    if (/^\s{6}mode:\s*/.test(next)) {
+      providers.push(name);
+    }
+  }
+
+  return providers;
+}
+
+async function parseLocalTaskStatus(filePath) {
+  const content = await fs.readFile(filePath, "utf8");
+  const id = path.basename(filePath, ".md");
+  const statusMatch = content.match(/^\-\s+Status:\s*(.+)$/m);
+  const shortNameMatch = content.match(/^\-\s+Short Name:\s*(.+)$/m);
+
+  return {
+    id,
+    shortName: (shortNameMatch?.[1] || "").trim(),
+    status: (statusMatch?.[1] || "UNKNOWN").trim(),
+  };
+}
+
+async function listLocalTaskFiles() {
+  const tasksDir = path.resolve(process.cwd(), "tasks");
+  try {
+    const entries = await fs.readdir(tasksDir, { withFileTypes: true });
+    return entries
+      .filter((entry) => entry.isFile() && entry.name.endsWith(".md") && !EXCLUDED_TASK_FILES.has(entry.name) && !entry.name.startsWith("sprint-"))
+      .map((entry) => path.join(tasksDir, entry.name));
+  } catch {
+    return [];
+  }
+}
+
+async function parseLocalSprint() {
+  const tasksDir = path.resolve(process.cwd(), "tasks");
+  let entries;
+
+  try {
+    entries = await fs.readdir(tasksDir, { withFileTypes: true });
+  } catch {
+    return { id: "", status: "", source: "none" };
+  }
+
+  const sprintFiles = entries
+    .filter((entry) => entry.isFile() && /^sprint-.*\.md$/i.test(entry.name))
+    .map((entry) => path.join(tasksDir, entry.name));
+
+  if (sprintFiles.length === 0) {
+    return { id: "", status: "", source: "none" };
+  }
+
+  const parsed = [];
+  for (const file of sprintFiles) {
+    const content = await fs.readFile(file, "utf8");
+    const idMatch = content.match(/^\-\s+Sprint ID:\s*(.+)$/m);
+    const statusMatch = content.match(/^\-\s+Status:\s*(.+)$/m);
+    parsed.push({
+      file,
+      id: (idMatch?.[1] || path.basename(file, ".md")).trim(),
+      status: (statusMatch?.[1] || "UNKNOWN").trim(),
+    });
+  }
+
+  const active = parsed.find((item) => /IN_PROGRESS|ACTIVE/i.test(item.status));
+  return active || parsed[0];
+}
+
+async function parseLocalStatusLogCurrentTask() {
+  const file = path.resolve(process.cwd(), "tasks", "task-status-log.md");
+  let content = "";
+  try {
+    content = await fs.readFile(file, "utf8");
+  } catch {
+    return "";
+  }
+
+  const lines = content.split("\n").map((line) => line.trim());
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    const line = lines[i];
+    const match = line.match(/^\-\s*\d{4}-\d{2}-\d{2}\s*\|\s*([A-Z][A-Z0-9_]*-\d+)\s*\|\s*([A-Z_]+)\s*\|/);
+    if (!match) {
+      continue;
+    }
+
+    const taskId = match[1];
+    const status = match[2];
+    if (!["DONE", "PUBLISH", "BLOCKED"].includes(status)) {
+      return `${taskId} (${status})`;
+    }
+  }
+
+  return "";
+}
+
+function detectTaskFromBranch(branch) {
+  const taskRef = extractBranchTaskRef(branch);
+  if (!taskRef) {
+    return "";
+  }
+  if (/^\d+$/.test(taskRef)) {
+    return `#${taskRef}`;
+  }
+  return taskRef;
+}
+
+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 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 uppercaseToken = tail.match(/^([A-Z][A-Z0-9_]*-\d+)/);
+  if (uppercaseToken) {
+    return uppercaseToken[1].toUpperCase();
+  }
+
+  const numericToken = tail.match(/^(\d+)(?:-|$)/);
+  if (numericToken) {
+    return numericToken[1];
+  }
+
+  return "";
+}
+
+function extractTaskRefFromCurrentTask(currentTask) {
+  const source = String(currentTask || "").trim();
+  if (!source) {
+    return "";
+  }
+
+  const issueMatch = source.match(/#(\d+)/);
+  if (issueMatch) {
+    return issueMatch[1];
+  }
+
+  const taskMatch = source.match(/\b([A-Z][A-Z0-9_]*-\d+)\b/);
+  if (taskMatch) {
+    return taskMatch[1].toUpperCase();
+  }
+
+  return "";
+}
+
+function computeBranchTaskAlignment({ branchType, branchTaskRef, currentTask }) {
+  const currentTaskRef = extractTaskRefFromCurrentTask(currentTask);
+  if (!currentTaskRef || !branchTaskRef) {
+    return {
+      status: "unknown",
+      currentTaskRef,
+    };
+  }
+
+  if (currentTaskRef === branchTaskRef) {
+    return {
+      status: "match",
+      currentTaskRef,
+    };
+  }
+
+  if (branchType === "feature") {
+    return {
+      status: "mismatch",
+      currentTaskRef,
+    };
+  }
+
+  return {
+    status: "unknown",
+    currentTaskRef,
+  };
+}
+
+function normalizeStatusRank(status) {
+  const idx = STATUS_LABELS.indexOf(status);
+  return idx === -1 ? 999 : idx;
+}
+
+function findSprintLabel(labels) {
+  for (const label of labels) {
+    const name = label.name || "";
+    if (/^sprint[:\-]/i.test(name) || /^SPRINT-\d+$/i.test(name)) {
+      return name;
+    }
+  }
+  return "";
+}
+
+function parseIssueStatus(labels) {
+  for (const label of labels) {
+    const name = (label.name || "").toUpperCase();
+    if (STATUS_LABELS.includes(name)) {
+      return name;
+    }
+  }
+  return "";
+}
+
+function pickCurrentLocalTask(localTasks) {
+  const priority = ["IN_PROGRESS", "REVIEW", "READY", "TODO", "BLOCKED"];
+  for (const target of priority) {
+    const found = localTasks.find((task) => String(task.status || "").toUpperCase() === target);
+    if (found) {
+      const short = found.shortName ? ` ${found.shortName}` : "";
+      return `${found.id}${short} (${target})`;
+    }
+  }
+  return "";
+}
+
+function readJson(command, args) {
+  const raw = run(command, args, false);
+  return JSON.parse(raw || "null");
+}
+
+function collectGithubWorkflow() {
+  try {
+    run("gh", ["--version"], false);
+  } catch {
+    return { available: false, reason: "gh CLI not installed" };
+  }
+
+  const auth = run("gh", ["auth", "status"], true);
+  if (!auth) {
+    return { available: false, reason: "gh auth status unavailable" };
+  }
+
+  try {
+    const repo = readJson("gh", ["repo", "view", "--json", "nameWithOwner,defaultBranchRef"]);
+    const issues = readJson("gh", ["issue", "list", "--state", "open", "--limit", "100", "--json", "number,title,labels"]);
+
+    const normalizedIssues = (issues || []).map((issue) => {
+      const labels = issue.labels || [];
+      const status = parseIssueStatus(labels) || "UNLABELED";
+      const sprint = findSprintLabel(labels);
+      return {
+        number: issue.number,
+        title: issue.title || "",
+        status,
+        sprint,
+      };
+    });
+
+    normalizedIssues.sort((a, b) => normalizeStatusRank(a.status) - normalizeStatusRank(b.status));
+
+    const currentIssue = normalizedIssues.find((issue) => ["IN_PROGRESS", "REVIEW", "READY", "BLOCKED", "TODO"].includes(issue.status)) || null;
+
+    const sprintCounts = new Map();
+    for (const issue of normalizedIssues) {
+      if (!issue.sprint) {
+        continue;
+      }
+      sprintCounts.set(issue.sprint, (sprintCounts.get(issue.sprint) || 0) + 1);
+    }
+
+    let currentSprint = "";
+    let maxCount = 0;
+    for (const [sprint, count] of sprintCounts.entries()) {
+      if (count > maxCount) {
+        maxCount = count;
+        currentSprint = sprint;
+      }
+    }
+
+    return {
+      available: true,
+      repo: repo?.nameWithOwner || "",
+      defaultBranch: repo?.defaultBranchRef?.name || "",
+      currentIssue,
+      currentSprint,
+      openIssues: normalizedIssues.length,
+    };
+  } catch (error) {
+    return {
+      available: false,
+      reason: `github query failed: ${error.message}`,
+    };
+  }
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const trackerProvider = resolveTrackerForCommand({
+    requestedTracker: options.tracker,
+    cwd: process.cwd(),
+  });
+
+  const git = collectGitSummary();
+  const providers = await readTrackersConfig();
+  const localTaskFiles = await listLocalTaskFiles();
+  const localTasks = [];
+
+  for (const file of localTaskFiles) {
+    localTasks.push(await parseLocalTaskStatus(file));
+  }
+
+  const localSprint = await parseLocalSprint();
+  const localCurrentTask = await parseLocalStatusLogCurrentTask();
+  const branchTask = detectTaskFromBranch(git.branch);
+
+  let currentTask = "";
+  let currentSprint = "";
+  let workflowSource = "";
+  const notes = [];
+
+  if (trackerProvider === "github") {
+    const gh = collectGithubWorkflow();
+    if (gh.available) {
+      workflowSource = `github:${gh.repo || "unknown"}`;
+      currentTask = gh.currentIssue ? `#${gh.currentIssue.number} ${gh.currentIssue.title} (${gh.currentIssue.status})` : "";
+      currentSprint = gh.currentSprint || (gh.currentIssue?.sprint || "");
+      notes.push(`GitHub issues open: ${gh.openIssues}`);
+    } else {
+      workflowSource = "github (fallback)";
+      notes.push(`GitHub tracker snapshot unavailable: ${gh.reason}`);
+      if (options.includeLocalCache) {
+        currentTask = localCurrentTask || branchTask;
+        currentSprint = localSprint.id || "";
+        notes.push("Used local tasks cache because --include-local-cache is enabled.");
+      } else {
+        currentTask = branchTask;
+      }
+    }
+
+    if (localTasks.length > 0) {
+      notes.push(
+        `Detected ${localTasks.length} local task file(s) in tasks/ (treated as cache, non-authoritative for github tracker).`,
+      );
+    }
+  } else if (trackerProvider === "local") {
+    workflowSource = "local tasks";
+    currentTask = localCurrentTask || pickCurrentLocalTask(localTasks) || branchTask;
+    currentSprint = localSprint.id || "";
+  } else {
+    workflowSource = trackerProvider;
+    currentTask = branchTask;
+    if (localTasks.length > 0) {
+      notes.push(`Detected ${localTasks.length} local task file(s) in tasks/ (cache).`);
+    }
+  }
+
+  const branchTaskAlignment = computeBranchTaskAlignment({
+    branchType: git.branchType,
+    branchTaskRef: git.branchTaskRef,
+    currentTask,
+  });
+  const currentTaskRef = branchTaskAlignment.currentTaskRef;
+
+  if (git.branchType === "main") {
+    notes.push("Current branch is main; task-level implementation should run on feature/release/hotfix branches.");
+  }
+  if (git.branchType === "develop" && currentTaskRef) {
+    notes.push("Current task detected on develop; create a working branch before implementation changes.");
+  }
+  if (branchTaskAlignment.status === "match" && git.branchType === "feature") {
+    notes.push("Current task matches feature branch; atomic subtasks can stay in this branch.");
+  }
+  if (branchTaskAlignment.status === "mismatch") {
+    notes.push(
+      `Current task (${currentTaskRef}) is different from branch context (${git.branchTaskRef}); switch to develop and create a dedicated branch.`,
+    );
+  }
+
+  const report = {
+    tracker: {
+      lockedProvider: trackerProvider,
+      availableProviders: providers,
+      workflowSource,
+    },
+    process: {
+      currentSprint: currentSprint || "not detected",
+      currentTask: currentTask || "not detected",
+      currentTaskRef: currentTaskRef || "not detected",
+      branchTaskAlignment: branchTaskAlignment.status,
+    },
+    git: {
+      branch: git.branch,
+      branchType: git.branchType,
+      branchTaskRef: git.branchTaskRef || "not detected",
+      upstream: git.upstream || "not configured",
+      ahead: git.ahead,
+      behind: git.behind,
+      modifiedOrStaged: git.modifiedOrStaged,
+      untracked: git.untracked,
+      changedFiles: git.changedFiles,
+    },
+    summary: notes,
+  };
+
+  if (options.json) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+
+  console.log("# Status Snapshot");
+  console.log("");
+  console.log("## Trackers");
+  console.log(`- locked provider: ${report.tracker.lockedProvider}`);
+  console.log(`- available providers: ${report.tracker.availableProviders.join(", ") || "unknown"}`);
+  console.log(`- workflow source: ${report.tracker.workflowSource}`);
+
+  console.log("");
+  console.log("## Process");
+  console.log(`- current sprint: ${report.process.currentSprint}`);
+  console.log(`- current task: ${report.process.currentTask}`);
+  console.log(`- current task ref: ${report.process.currentTaskRef}`);
+  console.log(`- branch/task alignment: ${report.process.branchTaskAlignment}`);
+
+  console.log("");
+  console.log("## Git");
+  console.log(`- branch: ${report.git.branch}`);
+  console.log(`- branch type: ${report.git.branchType}`);
+  console.log(`- branch task ref: ${report.git.branchTaskRef}`);
+  console.log(`- upstream: ${report.git.upstream}`);
+  console.log(`- ahead/behind: ${report.git.ahead}/${report.git.behind}`);
+  console.log(`- modified_or_staged: ${report.git.modifiedOrStaged}`);
+  console.log(`- untracked: ${report.git.untracked}`);
+
+  if (report.git.changedFiles.length > 0) {
+    console.log("- changed files:");
+    for (const file of report.git.changedFiles.slice(0, 20)) {
+      console.log(`  - ${file}`);
+    }
+    if (report.git.changedFiles.length > 20) {
+      console.log(`  - ... +${report.git.changedFiles.length - 20} more`);
+    }
+  }
+
+  console.log("");
+  console.log("## Summary");
+  if (report.summary.length === 0) {
+    console.log("- no additional notes");
+  } else {
+    for (const item of report.summary) {
+      console.log(`- ${item}`);
+    }
+  }
+}
+
+main().catch((error) => {
+  console.error(`sync-status FAIL: ${error.message}`);
+  process.exit(1);
+});