deuk-agent-flow 4.2.7 → 5.0.2

package/scripts/cli-ticket-index.mjs

@@ -1,322 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, unlinkSync } from "fs";
-import { basename, dirname, join, resolve } from "path";
-import { hostname as osHostname } from "os";
-import { 
-  AGENT_ROOT_DIR, TICKET_SUBDIR, TICKET_INDEX_FILENAME,
-  requireNonEmptySlug, findFileRecursively, toRepoRelativePath, detectConsumerTicketDir, computeTicketPath, normalizeTicketGroup
-} from "./cli-utils.mjs";
-
-const TICKET_ARCHIVE_INDEX_FILENAME = "INDEX.archive.json";
-const TICKET_ARCHIVE_INDEX_PREFIX = "INDEX.archive.";
-const ARCHIVE_INDEX_RETENTION_MONTHS = 12;
-const ARCHIVE_INDEX_MONTH_RE = /^INDEX\.archive\.(\d{4}-\d{2})\.json$/;
-const ARCHIVE_INDEX_LEGACY_RE = /^INDEX\.archive\.json$/;
-
-function parseNextTicketSequence(value) {
-  const raw = Number(value);
-  if (!Number.isInteger(raw) || raw < 1) return null;
-  return raw;
-}
-
-function maxTicketNumberFromEntries(entries = []) {
-  const newRe = /^([0-9]{3,4})-/;
-  let max = 0;
-  for (const e of (entries || [])) {
-    const id = String(e.id || '');
-    const m = id.match(newRe);
-    if (m) {
-      const n = parseInt(m[1], 10);
-      if (n > max) max = n;
-    }
-  }
-  return max;
-}
-
-function normalizeNextTicketSequence(nextTicketSequence, entries = []) {
-  const fallbackNum = maxTicketNumberFromEntries(entries);
-  const fallbackNext = fallbackNum < 9999 ? (fallbackNum + 1) : fallbackNum;
-  const parsed = parseNextTicketSequence(nextTicketSequence);
-  if (parsed === null) return fallbackNext || 1;
-  return Math.max(parsed, fallbackNext || 1);
-}
-
-function parseArchiveMonth(value) {
-  const match = String(value || "").match(/^(\d{4})-(\d{2})$/);
-  if (!match) return null;
-  const year = Number(match[1]);
-  const month = Number(match[2]);
-  if (!Number.isInteger(year) || !Number.isInteger(month) || month < 1 || month > 12) return null;
-  return { year, month, yearMonth: `${match[1]}-${match[2]}` };
-}
-
-function monthDistance(fromYearMonth, toDate = new Date()) {
-  const parsed = parseArchiveMonth(fromYearMonth);
-  if (!parsed) return null;
-  return (toDate.getUTCFullYear() * 12 + toDate.getUTCMonth()) - ((parsed.year * 12) + (parsed.month - 1));
-}
-
-function resolveArchivePartition(entry, now = new Date()) {
-  const fromEntry = parseArchiveMonth(entry?.archiveYearMonth);
-  if (fromEntry) {
-    return {
-      yearMonth: fromEntry.yearMonth
-    };
-  }
-
-  const source = String(entry?.createdAt || entry?.updatedAt || "");
-  const match = source.match(/^(\d{4})-(\d{2})-(\d{2})/);
-  if (match) {
-    return { yearMonth: `${match[1]}-${match[2]}` };
-  }
-
-  return {
-    yearMonth: `${now.getUTCFullYear()}-${String(now.getUTCMonth() + 1).padStart(2, "0")}`
-  };
-}
-
-function shouldRetainArchiveEntry(entry, now = new Date()) {
-  const partition = resolveArchivePartition(entry, now);
-  const distance = monthDistance(partition.yearMonth, now);
-  if (distance === null) return true;
-  return distance <= ARCHIVE_INDEX_RETENTION_MONTHS;
-}
-
-function archiveIndexFilePath(dir, yearMonth = null) {
-  return join(dir, yearMonth ? `${TICKET_ARCHIVE_INDEX_PREFIX}${yearMonth}.json` : TICKET_ARCHIVE_INDEX_FILENAME);
-}
-
-function listArchiveIndexFiles(dir) {
-  if (!existsSync(dir)) return [];
-  return readdirSync(dir, { withFileTypes: true })
-    .filter(ent => ent.isFile())
-    .map(ent => join(dir, ent.name))
-    .filter(abs => ARCHIVE_INDEX_LEGACY_RE.test(basename(abs)) || ARCHIVE_INDEX_MONTH_RE.test(basename(abs)))
-    .sort((a, b) => {
-      const aBase = basename(a);
-      const bBase = basename(b);
-      const aMatch = aBase.match(ARCHIVE_INDEX_MONTH_RE);
-      const bMatch = bBase.match(ARCHIVE_INDEX_MONTH_RE);
-      if (aMatch && !bMatch) return 1;
-      if (!aMatch && bMatch) return -1;
-      if (!aMatch && !bMatch) return aBase.localeCompare(bBase);
-      return aMatch[1].localeCompare(bMatch[1]);
-    });
-}
-
-function parseIndexFile(absPath) {
-  if (!existsSync(absPath)) {
-    return { version: 1, updatedAt: null, activeTicketId: null, nextTicketSequence: 1, entries: [] };
-  }
-  try {
-    const j = JSON.parse(readFileSync(absPath, "utf8"));
-    const entries = Array.isArray(j.entries) ? j.entries.map(e => {
-      const entry = { ...e, status: e.status || "open", group: normalizeTicketGroup(e.group, "sub") };
-      entry.path = computeTicketPath(entry);
-      return entry;
-    }) : [];
-    return {
-      version: j.version || 1,
-      updatedAt: j.updatedAt ?? null,
-      activeTicketId: j.activeTicketId ?? null,
-      nextTicketSequence: parseNextTicketSequence(j.nextTicketSequence),
-      entries
-    };
-  } catch (err) {
-    console.error(`[ERROR] Failed to parse ${basename(absPath)} at ${absPath}:`, err.message);
-    return { version: 1, updatedAt: null, activeTicketId: null, nextTicketSequence: 1, entries: [], _corrupt: true };
-  }
-}
-
-function splitEntriesForStorage(entries = []) {
-  const activeEntries = [];
-  const archiveEntries = [];
-  for (const entry of entries) {
-    const status = String(entry?.status || "open").toLowerCase();
-    if (status === "open" || status === "active") {
-      activeEntries.push(entry);
-    } else {
-      archiveEntries.push(entry);
-    }
-  }
-  return { activeEntries, archiveEntries };
-}
-
-function partitionArchiveEntries(entries = []) {
-  const retained = [];
-  const retired = [];
-  for (const entry of entries) {
-    if (shouldRetainArchiveEntry(entry)) retained.push(entry);
-    else retired.push(entry);
-  }
-  return { retained, retired };
-}
-
-function mergeIndexEntries(primaryEntries = [], archiveEntries = []) {
-  const merged = new Map();
-  for (const entry of primaryEntries || []) {
-    if (entry?.id) merged.set(entry.id, entry);
-  }
-  for (const entry of archiveEntries || []) {
-    if (entry?.id) merged.set(entry.id, entry);
-  }
-  return Array.from(merged.values());
-}
-
-export function readTicketIndexJson(cwd) {
-  const dir = detectConsumerTicketDir(cwd);
-  if (!dir) return { version: 1, updatedAt: null, entries: [] };
-  const mainPath = join(dir, TICKET_INDEX_FILENAME);
-  const main = parseIndexFile(mainPath);
-  const archiveFiles = listArchiveIndexFiles(dir).map(parseIndexFile);
-
-  const archiveEntries = archiveFiles.flatMap(file => file.entries || []);
-  const entries = mergeIndexEntries(main.entries, archiveEntries).map(entry => {
-    const next = { ...entry, status: entry.status || "open", group: normalizeTicketGroup(entry.group, "sub") };
-    next.path = computeTicketPath(next);
-    return next;
-  });
-
-  return {
-    version: main.version || archiveFiles[0]?.version || 1,
-    updatedAt: main.updatedAt ?? archiveFiles[0]?.updatedAt ?? null,
-    activeTicketId: main.activeTicketId ?? null,
-    nextTicketSequence: normalizeNextTicketSequence(main.nextTicketSequence, entries),
-    entries,
-    _corrupt: Boolean(main._corrupt || archiveFiles.some(file => file._corrupt))
-  };
-}
-
-export function writeTicketIndexJson(cwd, indexJson, opts = {}) {
-  if (indexJson._corrupt && !opts.force) {
-    console.error(`[ABORT] Refusing to overwrite potentially corrupt ${TICKET_INDEX_FILENAME}. Use --force to override.`);
-    return;
-  }
-  const dir = detectConsumerTicketDir(cwd, { createIfMissing: true });
-  const p = join(dir, TICKET_INDEX_FILENAME);
-  if (opts.dryRun) return;
-  mkdirSync(dir, { recursive: true });
-  
-  const out = { ...indexJson };
-  delete out._corrupt;
-  out.nextTicketSequence = normalizeNextTicketSequence(out.nextTicketSequence, out.entries || []);
-  
-  // Strip physical path snapshots before saving to enforce state-driven resolution
-  const entries = Array.isArray(out.entries) ? out.entries : [];
-  const { activeEntries, archiveEntries } = splitEntriesForStorage(entries);
-  out.entries = activeEntries.map(e => {
-    const { path, archiveDay, ...clean } = e;
-    return clean;
-  });
-  out.activeTicketId = out.activeTicketId || activeEntries.find(e => e.status === "active")?.id || activeEntries.find(e => e.status === "open")?.id || null;
-  writeFileSync(p, JSON.stringify(out, null, 2) + "\n", "utf8");
-
-  const archiveFiles = listArchiveIndexFiles(dir);
-  const retainedArchiveEntries = partitionArchiveEntries(archiveEntries);
-  const archiveBuckets = new Map();
-
-  for (const entry of retainedArchiveEntries.retained) {
-    const partition = resolveArchivePartition(entry);
-    const bucket = archiveBuckets.get(partition.yearMonth) || [];
-    bucket.push({ ...entry, archiveYearMonth: partition.yearMonth });
-    archiveBuckets.set(partition.yearMonth, bucket);
-  }
-
-  const desiredArchiveFiles = new Set();
-  for (const [yearMonth, bucket] of archiveBuckets.entries()) {
-  const archiveOut = {
-      version: out.version || 1,
-      updatedAt: out.updatedAt || new Date().toISOString(),
-      activeTicketId: null,
-      nextTicketSequence: out.nextTicketSequence,
-      entries: bucket.map(e => {
-        const { path, archiveDay, ...clean } = e;
-        return clean;
-      })
-    };
-    const archivePath = archiveIndexFilePath(dir, yearMonth);
-    desiredArchiveFiles.add(archivePath);
-    writeFileSync(archivePath, JSON.stringify(archiveOut, null, 2) + "\n", "utf8");
-  }
-
-  for (const filePath of archiveFiles) {
-    if (!desiredArchiveFiles.has(filePath)) {
-      unlinkSync(filePath);
-    }
-  }
-
-  if (retainedArchiveEntries.retired.length > 0) {
-    console.log(`[GC] Dropped ${retainedArchiveEntries.retired.length} archived entries outside the ${ARCHIVE_INDEX_RETENTION_MONTHS}-month retention window.`);
-  }
-}
-
-export function getHostnameSlug() {
-  try {
-    const slug = osHostname().toLowerCase().replace(/[^a-z0-9\-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
-    return slug.slice(0, 8).replace(/-$/, '') || 'local';
-  } catch {
-    return 'local';
-  }
-}
-
-export function computeNextTicketNumber(indexState) {
-  const hostname = getHostnameSlug();
-  const maybeEntries = Array.isArray(indexState) ? indexState : indexState?.entries;
-  const parsedNext = normalizeNextTicketSequence(indexState?.nextTicketSequence, maybeEntries);
-  return { num: parsedNext, hostname };
-}
-
-export function generateTicketId(topicSlug, indexState) {
-  const hostname = getHostnameSlug();
-  const slug = requireNonEmptySlug(topicSlug, "ticket topic");
-  const match = slug.match(/^(\d{3,4})-(.*)/);
-  if (match) {
-    const numStr = match[1];
-    const restSlug = match[2].slice(0, 32);
-    return `${numStr}-${restSlug}-${hostname}`;
-  }
-  const { num } = computeNextTicketNumber(indexState);
-  const numStr = String(num).padStart(3, '0');
-  const finalSlug = slug.slice(0, 32);
-  return `${numStr}-${finalSlug}-${hostname}`;
-}
-
-export function syncActiveTicketId(cwd, opts = {}) {
-  const index = readTicketIndexJson(cwd);
-  const activeEntries = index.entries.filter(e => e.status === "active");
-  const openEntries = index.entries.filter(e => e.status === "open");
-  const newestFirst = (a, b) => String(b.updatedAt || b.createdAt || "").localeCompare(String(a.updatedAt || a.createdAt || ""));
-  const activeEntry = activeEntries.sort(newestFirst)[0] || openEntries.sort(newestFirst)[0] || null;
-  
-  const ticketDir = detectConsumerTicketDir(cwd);
-  if (!ticketDir) return;
-  if (opts.dryRun) return;
-
-  const activeId = activeEntry ? activeEntry.id : null;
-  if (index.activeTicketId !== activeId) {
-      writeTicketIndexJson(cwd, { ...index, activeTicketId: activeId });
-  }
-
-  const legacyLatestPath = join(ticketDir, "LATEST.md");
-  const pointerPathMd = join(ticketDir, "ACTIVE_TICKET.md");
-  const pointerPathJson = join(ticketDir, "ACTIVE_TICKET.json");
-  
-  for (const p of [legacyLatestPath, pointerPathMd, pointerPathJson]) {
-    if (existsSync(p)) {
-      unlinkSync(p);
-    }
-  }
-}
-
-export async function syncToPipeline(url, data) {
-  try {
-    const response = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(data),
-      signal: AbortSignal?.timeout ? AbortSignal.timeout(3000) : undefined
-    });
-    return response.ok;
-  } catch (err) {
-    return false;
-  }
-}

package/scripts/cli-ticket-parser.mjs

@@ -1,210 +0,0 @@
-import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
-import { basename, dirname, join } from "path";
-import {
-  AGENT_ROOT_DIR, TICKET_SUBDIR, TICKET_LIST_FILENAME,
-  toPosixPath, toRepoRelativePath, detectProjectFromBody, deriveTopicFromBaseName, normalizeTicketGroup,
-  parseFrontMatter, stringifyFrontMatter, discoverAllWorkspaces, detectConsumerTicketDir, computeTicketPath,
-  ARCHIVE_YEAR_MONTH_RE, ARCHIVE_DAY_RE
-} from "./cli-utils.mjs";
-import { readTicketIndexJson, writeTicketIndexJson } from "./cli-ticket-index.mjs";
-
-export function collectTicketMarkdownFiles(dir, out = []) {
-  if (!existsSync(dir)) return out;
-  for (const ent of readdirSync(dir, { withFileTypes: true })) {
-    const abs = join(dir, ent.name);
-    if (ent.name === "node_modules" || ent.name === ".git") continue;
-    if (ent.isDirectory()) collectTicketMarkdownFiles(abs, out);
-    else if (ent.isFile() && /\.md$/i.test(ent.name)) {
-      const base = ent.name;
-      if (base === "LATEST.md" || base === TICKET_LIST_FILENAME || base === "ACTIVE_TICKET.md") continue;
-      out.push(abs);
-    }
-  }
-  return out;
-}
-
-export function discoverAllTicketDirs(baseCwd, out = []) {
-  return discoverAllWorkspaces(baseCwd, undefined, new Set(out));
-}
-
-export function rebuildTicketIndexFromTopicFilesIfNeeded(cwd, opts = {}) {
-  const indexJson = readTicketIndexJson(cwd);
-  
-  if (indexJson.entries.length > 0 && !opts.force && !opts.rebuild) {
-    return indexJson;
-  }
-
-  const ticketDir = detectConsumerTicketDir(cwd);
-  if (!ticketDir) return indexJson;
-
-  // Strictly scan only the official ticket system directory and its subdirectories
-  const ticketDirs = [ticketDir];
-
-
-  if (ticketDirs.length === 0) return indexJson;
-
-  const files = [];
-  for (const dir of ticketDirs) {
-    collectTicketMarkdownFiles(dir, files);
-  }
-
-  let dirty = false;
-  const newEntries = [];
-
-  for (let i = 0; i < files.length; i++) {
-    const entry = processTicketFile(files[i], cwd, indexJson, opts);
-    if (entry) newEntries.push(entry);
-  }
-
-  if (JSON.stringify(indexJson.entries) !== JSON.stringify(newEntries)) {
-    dirty = true;
-  }
-
-  if (dirty || opts.force || opts.rebuild) {
-    newEntries.sort((a,b) => String(b.createdAt||"").localeCompare(String(a.createdAt||"")));
-    const next = { version: 1, updatedAt: new Date().toISOString(), entries: newEntries };
-    writeTicketIndexJson(cwd, next, opts);
-    if (opts.rebuild) console.log(`[REBUILD] INDEX.json rebuilt with ${newEntries.length} entries.`);
-    return next;
-  }
-
-  return indexJson;
-}
-
-function processTicketFile(abs, cwd, indexJson, opts) {
-  const rel = toPosixPath(toRepoRelativePath(cwd, abs));
-  const filename = basename(abs);
-  const idFromFilename = filename.replace(/\.md$/i, "");
-  const isAlreadyInArchive = rel.includes("/archive/");
-  const storage = parseTicketStorage(rel, isAlreadyInArchive, abs);
-  const group = storage.group;
-
-  // Optimization: If entry already exists in index and not forced, reuse metadata to save I/O & tokens
-  const existing = indexJson.entries.find(e => e.id === idFromFilename);
-  if (existing && !opts.force) {
-    return {
-      ...existing,
-      group,
-      archiveYearMonth: storage.archiveYearMonth || existing.archiveYearMonth,
-      status: isAlreadyInArchive ? "archived" : (existing.status === "archived" ? "open" : existing.status),
-      updatedAt: statSync(abs).mtime.toISOString()
-    };
-  }
-
-  // New or forced entry: Parse file content
-  let meta = {}, content = "";
-  try {
-    const body = readFileSync(abs, "utf8");
-    const parsed = parseFrontMatter(body);
-    meta = parsed.meta;
-    content = parsed.content;
-  } catch (err) {
-    console.warn(`[WARNING] Failed to parse ${rel}: ${err.message}`);
-  }
-
-  const title = meta.title || idFromFilename;
-  const project = meta.project || detectProjectFromBody(content);
-
-  return {
-    id: meta.id || idFromFilename,
-    title,
-    topic: deriveTopicFromBaseName(filename),
-    group,
-    fileName: filename,
-    project,
-    submodule: meta.submodule || (rel.startsWith(AGENT_ROOT_DIR) ? "" : rel.split("/")[0]),
-    createdAt: meta.createdAt || statSync(abs).mtime.toISOString(),
-    updatedAt: statSync(abs).mtime.toISOString(),
-    source: "ticket-sync",
-    status: isAlreadyInArchive ? "archived" : (meta.status || "open"),
-    archiveYearMonth: storage.archiveYearMonth,
-  };
-}
-
-function parseTicketStorage(rel, isArchived, abs) {
-  if (!isArchived) {
-    return { group: basename(dirname(abs)) };
-  }
-
-  const parts = rel.split("/");
-  const archiveIdx = parts.indexOf("archive");
-  const group = parts[archiveIdx + 1] || basename(dirname(abs));
-  const maybeYearMonth = parts[archiveIdx + 2];
-  const maybeDay = parts[archiveIdx + 3];
-
-  if (ARCHIVE_YEAR_MONTH_RE.test(String(maybeYearMonth || "")) && ARCHIVE_DAY_RE.test(String(maybeDay || ""))) {
-    return { group: normalizeTicketGroup(group), archiveYearMonth: maybeYearMonth, archiveDay: maybeDay };
-  }
-
-  if (ARCHIVE_YEAR_MONTH_RE.test(String(maybeYearMonth || ""))) {
-    return { group: normalizeTicketGroup(group), archiveYearMonth: maybeYearMonth };
-  }
-
-  return { group: normalizeTicketGroup(group) };
-}
-
-export function appendTicketEntry(cwd, entry, opts = {}) {
-  const indexJson = readTicketIndexJson(cwd);
-  entry.status = entry.status || "open";
-  // We no longer store 'path' snapshots in INDEX.json
-  const { path, ...cleanEntry } = entry;
-  const next = { 
-    version: indexJson.version || 1, 
-    updatedAt: new Date().toISOString(), 
-    activeTicketId: indexJson.activeTicketId, 
-    entries: [cleanEntry, ...indexJson.entries] 
-  };
-  writeTicketIndexJson(cwd, next, opts);
-}
-
-export function updateTicketEntryStatus(cwd, opts = {}) {
-  const indexJson = rebuildTicketIndexFromTopicFilesIfNeeded(cwd, opts);
-  let foundIndex = -1;
-  const targetTopic = opts.topic ? String(opts.topic).toLowerCase() : null;
-  
-  if (opts.latest) {
-    foundIndex = 0;
-  } else if (targetTopic) {
-    // Match against both topic AND id for consistency with pickTicketEntry
-    foundIndex = indexJson.entries.findIndex(e =>
-      String(e.topic || "").toLowerCase().includes(targetTopic) ||
-      String(e.id || "").toLowerCase().includes(targetTopic)
-    );
-  }
-
-  if (foundIndex === -1) {
-    throw new Error("No matching ticket found to update status");
-  }
-
-  const entry = indexJson.entries[foundIndex];
-  const newStatus = opts.status || "closed";
-  entry.status = newStatus;
-  if (newStatus === "closed" || newStatus === "cancelled" || newStatus === "wontfix") {
-    entry.phase = 4;
-  }
-  entry.updatedAt = new Date().toISOString();
-  
-  // Sync status back to .md frontmatter to prevent rebuild reversion
-  const entryPath = entry.path || computeTicketPath(entry);
-  const absPath = join(cwd, entryPath);
-  if (existsSync(absPath)) {
-    try {
-      const body = readFileSync(absPath, "utf8");
-      const parsed = parseFrontMatter(body);
-      if (parsed.meta.status !== newStatus) {
-        parsed.meta.status = newStatus;
-        if (newStatus === "closed" || newStatus === "cancelled" || newStatus === "wontfix") {
-          parsed.meta.phase = 4;
-        }
-        const newBody = stringifyFrontMatter(parsed.meta, parsed.content);
-        writeFileSync(absPath, newBody, "utf8");
-      }
-    } catch (err) {
-      console.warn(`[WARNING] Failed to sync status to ${entryPath}: ${err.message}`);
-    }
-  }
-
-  const next = { version: indexJson.version, updatedAt: new Date().toISOString(), entries: indexJson.entries };
-  writeTicketIndexJson(cwd, next, opts);
-  return entry;
-}