create-byan-agent 2.9.4 → 2.9.6

package/install/bin/byan-cleanup.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+/**
+ * BYAN cleanup CLI.
+ *
+ * Scans the current project for stale Claude Code skills and stale
+ * root-level doc files, then archives them (safe default) or hard
+ * deletes (with --hard).
+ *
+ * Flags :
+ *   --dry-run   list candidates, do nothing
+ *   --yes       skip confirmation (batch mode)
+ *   --hard      delete instead of archive
+ *   --skills-only | --docs-only   restrict scope
+ *   --root <dir>  override project root (default cwd)
+ */
+
+const path = require('path');
+const { findStaleSkills, findStaleDocs } = require('../lib/cleanup/detector');
+const { archive, deleteHard } = require('../lib/cleanup/executor');
+
+function parseArgs(argv) {
+  const out = {
+    dryRun: false,
+    yes: false,
+    hard: false,
+    skillsOnly: false,
+    docsOnly: false,
+    root: process.cwd(),
+  };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--dry-run') out.dryRun = true;
+    else if (a === '--yes' || a === '-y') out.yes = true;
+    else if (a === '--hard') out.hard = true;
+    else if (a === '--skills-only') out.skillsOnly = true;
+    else if (a === '--docs-only') out.docsOnly = true;
+    else if (a === '--root') out.root = argv[++i];
+    else if (a === '-h' || a === '--help') out.help = true;
+  }
+  return out;
+}
+
+function usage() {
+  console.log(
+    [
+      'byan-cleanup — scan a BYAN project for stale skills + docs',
+      '',
+      'Usage:',
+      '  byan-cleanup [--dry-run] [--yes] [--hard] [--skills-only|--docs-only] [--root <dir>]',
+      '',
+      'Flags:',
+      '  --dry-run      list candidates, do nothing',
+      '  --yes          skip confirmation (batch mode)',
+      '  --hard         delete instead of archive (default: archive)',
+      '  --skills-only  scan only .claude/skills/',
+      '  --docs-only    scan only root *.md / *.txt',
+      '  --root <dir>   project root (default: cwd)',
+      '',
+      'Default behavior: archive to _byan-output/archive/<timestamp>/',
+    ].join('\n')
+  );
+}
+
+function fmtSize(n) {
+  if (n < 1024) return `${n}B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)}KB`;
+  return `${(n / 1024 / 1024).toFixed(1)}MB`;
+}
+
+function printGroup(label, items) {
+  if (items.length === 0) {
+    console.log(`\n  ${label}: none`);
+    return;
+  }
+  console.log(`\n  ${label} (${items.length}):`);
+  for (const it of items) {
+    console.log(`    - ${it.name}  ${fmtSize(it.size || 0)}`);
+    for (const r of it.reasons) console.log(`        · ${r}`);
+  }
+}
+
+async function confirm(prompt) {
+  if (process.stdin.isTTY) {
+    const readline = require('readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+      rl.question(prompt, (ans) => {
+        rl.close();
+        resolve(/^y(es)?$/i.test((ans || '').trim()));
+      });
+    });
+  }
+  // non-TTY : refuse action unless --yes
+  return false;
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+  if (args.help) {
+    usage();
+    process.exit(0);
+  }
+
+  const root = path.resolve(args.root);
+  const skillsDir = path.join(root, '.claude', 'skills');
+
+  const skills = args.docsOnly ? [] : findStaleSkills(skillsDir);
+  const docs = args.skillsOnly ? [] : findStaleDocs(root);
+
+  console.log(`BYAN cleanup scan — root: ${root}`);
+  printGroup('Stale skills', skills);
+  printGroup('Stale docs', docs);
+  const total = skills.length + docs.length;
+  console.log(`\n  Total candidates: ${total}`);
+
+  if (args.dryRun) {
+    console.log('\n--dry-run: no action taken.');
+    process.exit(0);
+  }
+
+  if (total === 0) {
+    console.log('Nothing to clean.');
+    process.exit(0);
+  }
+
+  const action = args.hard ? 'HARD DELETE (irreversible)' : 'archive to _byan-output/archive/<timestamp>/';
+  console.log(`\nAction: ${action}`);
+
+  let proceed = args.yes;
+  if (!proceed) {
+    proceed = await confirm(`Proceed with ${total} item(s) ? (y/N): `);
+  }
+
+  if (!proceed) {
+    console.log('Aborted.');
+    process.exit(0);
+  }
+
+  const all = [...skills, ...docs];
+  if (args.hard) {
+    const r = deleteHard(all);
+    console.log(`\nDeleted ${r.deleted.length} items.`);
+    if (r.errors.length) console.log(`Errors: ${r.errors.length}`);
+    for (const e of r.errors) console.log(`  ! ${e.path} — ${e.error}`);
+  } else {
+    const r = archive(all, { archiveRoot: path.join(root, '_byan-output', 'archive') });
+    console.log(`\nArchived ${r.moved.length} items to ${r.archiveDir}`);
+    if (r.errors.length) console.log(`Errors: ${r.errors.length}`);
+    for (const e of r.errors) console.log(`  ! ${e.path} — ${e.error}`);
+  }
+}
+
+main().catch((err) => {
+  console.error('byan-cleanup failed:', err.message);
+  process.exit(1);
+});

package/install/bin/byan-kanban.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+/**
+ * BYAN kanban CLI — view a party-mode-session board and stand-up feed.
+ *
+ * Usage :
+ *   byan-kanban <session-id>           # show board + recent stand-ups
+ *   byan-kanban <session-id> --json
+ *   byan-kanban <session-id> --standups-only
+ *   byan-kanban list                   # list known sessions with boards
+ *   byan-kanban <session-id> --root <dir>
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const COLORS = { todo: 90, doing: 33, blocked: 31, review: 36, done: 32, dim: 2, reset: 0 };
+const FG = (n, s) => `\x1b[${n}m${s}\x1b[0m`;
+
+function parseArgs(argv) {
+  const out = { json: false, standupsOnly: false, root: process.cwd(), sessionId: null, list: false };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--json') out.json = true;
+    else if (a === '--standups-only') out.standupsOnly = true;
+    else if (a === '--root') out.root = argv[++i];
+    else if (a === 'list') out.list = true;
+    else if (!out.sessionId) out.sessionId = a;
+  }
+  return out;
+}
+
+function sessionsRoot(root) {
+  return path.join(root, '_byan-output', 'party-mode-sessions');
+}
+
+function listSessions(root) {
+  const dir = sessionsRoot(root);
+  if (!fs.existsSync(dir)) return [];
+  return fs
+    .readdirSync(dir, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => {
+      const kanban = path.join(dir, e.name, 'kanban.json');
+      const standup = path.join(dir, e.name, 'standup.jsonl');
+      return {
+        session_id: e.name,
+        has_kanban: fs.existsSync(kanban),
+        has_standup: fs.existsSync(standup),
+      };
+    })
+    .sort((a, b) => (a.session_id < b.session_id ? 1 : -1));
+}
+
+function renderBoard(board) {
+  if (!board) return '(no kanban for this session)';
+  const cols = board.columns || ['todo', 'doing', 'blocked', 'review', 'done'];
+  const rows = cols.map((c) => {
+    const cards = Object.values(board.cards || {}).filter((card) => card.column === c);
+    return { col: c, cards };
+  });
+
+  const lines = [];
+  lines.push(FG(COLORS.dim, `session ${board.session_id} — updated ${board.updated_at}`));
+  lines.push('');
+  for (const r of rows) {
+    const color = COLORS[r.col] || 0;
+    lines.push(FG(color, `[${r.col.toUpperCase()}] (${r.cards.length})`));
+    if (r.cards.length === 0) {
+      lines.push(FG(COLORS.dim, '  (empty)'));
+    } else {
+      for (const c of r.cards) {
+        const assignee = c.assignee ? ` @${c.assignee}` : '';
+        const blocker = c.column === 'blocked' && c.blocker_reason ? ` — blocked: ${c.blocker_reason}` : '';
+        lines.push(`  - [${c.priority}] ${c.id} ${c.title}${assignee}${blocker}`);
+      }
+    }
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+function renderStandups(entries) {
+  if (entries.length === 0) return FG(COLORS.dim, '(no stand-ups yet)');
+  return entries
+    .map((e) => {
+      const blockers = e.blockers && e.blockers.length > 0
+        ? FG(COLORS.blocked, ` blockers=${e.blockers.join('|')}`)
+        : '';
+      return `${e.timestamp} ${e.agent}: ${e.did || '-'}${blockers} → ${e.next || '-'}`;
+    })
+    .join('\n');
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+  const root = path.resolve(args.root);
+
+  if (args.list || !args.sessionId) {
+    const sessions = listSessions(root);
+    if (args.json) {
+      process.stdout.write(JSON.stringify(sessions, null, 2) + '\n');
+      return;
+    }
+    if (sessions.length === 0) {
+      console.log('(no party-mode sessions found)');
+      return;
+    }
+    console.log('sessions :');
+    for (const s of sessions) {
+      const flags =
+        (s.has_kanban ? 'K' : '-') + (s.has_standup ? 'S' : '-');
+      console.log(`  [${flags}] ${s.session_id}`);
+    }
+    console.log('\npass a session id to view its board.');
+    return;
+  }
+
+  const sessionDir = path.join(sessionsRoot(root), args.sessionId);
+  const kanbanPath = path.join(sessionDir, 'kanban.json');
+  const standupPath = path.join(sessionDir, 'standup.jsonl');
+
+  let board = null;
+  if (fs.existsSync(kanbanPath)) {
+    try {
+      board = JSON.parse(fs.readFileSync(kanbanPath, 'utf8'));
+    } catch {
+      board = null;
+    }
+  }
+
+  let standups = [];
+  if (fs.existsSync(standupPath)) {
+    standups = fs
+      .readFileSync(standupPath, 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .map((l) => {
+        try {
+          return JSON.parse(l);
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean);
+  }
+
+  if (args.json) {
+    process.stdout.write(JSON.stringify({ board, standups }, null, 2) + '\n');
+    return;
+  }
+
+  if (!args.standupsOnly) {
+    console.log(renderBoard(board));
+  }
+  console.log('stand-ups :');
+  console.log(renderStandups(standups.slice(-10)));
+}
+
+main();

package/install/bin/byan-ledger.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+/**
+ * BYAN token ledger CLI.
+ *
+ * Usage :
+ *   byan-ledger                  # full session summary
+ *   byan-ledger --json           # machine-readable
+ *   byan-ledger --since 2026-04-19T15:00:00Z
+ *   byan-ledger --root <dir>     # override project root
+ */
+
+const path = require('path');
+const { readLog, summarize, renderReport, defaultLogPath } = require('../lib/token-ledger');
+
+function parseArgs(argv) {
+  const out = { json: false, since: null, root: process.cwd() };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--json') out.json = true;
+    else if (a === '--since') out.since = argv[++i];
+    else if (a === '--root') out.root = argv[++i];
+    else if (a === '-h' || a === '--help') out.help = true;
+  }
+  return out;
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+  if (args.help) {
+    console.log('byan-ledger [--json] [--since <iso>] [--root <dir>]');
+    process.exit(0);
+  }
+
+  const logPath = defaultLogPath(path.resolve(args.root));
+  const entries = readLog(logPath);
+  const stats = summarize(entries, { since: args.since });
+
+  if (args.json) {
+    process.stdout.write(JSON.stringify(stats, null, 2) + '\n');
+  } else {
+    process.stdout.write(renderReport(stats) + '\n');
+  }
+}
+
+main();

package/install/bin/create-byan-agent-v2.js

@@ -16,6 +16,7 @@ const { generateProjectAgentsDoc } = require('../lib/project-agents-generator');
 const { launchPhase2Chat, generateDefaultConfig } = require('../lib/phase2-chat');
 const { setupByanWebIntegration } = require('../lib/byan-web-integration');
 const { setupClaudeNative } = require('../lib/claude-native-setup');
+const { setupStagingConsent } = require('../lib/staging-consent');
 
 const BYAN_VERSION = require('../package.json').version;
 
@@ -1355,11 +1356,24 @@ async function install() {
   if (needsClaude || needsCopilot) {
     console.log();
     console.log(chalk.cyan('byan_web integration (optional — service payant)'));
+    let byanWebResult = { configured: false };
     try {
-      await setupByanWebIntegration(projectRoot);
+      byanWebResult = await setupByanWebIntegration(projectRoot);
     } catch (error) {
       console.log(chalk.yellow(`  ⚠ byan_web setup skipped: ${error.message}`));
     }
+
+    if (byanWebResult && byanWebResult.configured) {
+      console.log();
+      console.log(chalk.cyan('byan_web memory-sync opt-in (consent)'));
+      try {
+        await setupStagingConsent(projectRoot, {
+          byanWebConfigured: true,
+        });
+      } catch (error) {
+        console.log(chalk.yellow(`  ⚠ memory-sync setup skipped: ${error.message}`));
+      }
+    }
   }
 
   // Step 8: Create config.yaml

package/install/lib/cleanup/detector.js

@@ -0,0 +1,154 @@
+/**
+ * BYAN cleanup detector.
+ *
+ * Two scans :
+ *   - findStaleSkills(skillsDir)   : Claude Code skills under .claude/skills/
+ *     that look like auto-generated stubs with no real BYAN value (test
+ *     agents, self-referential, platform skills, or tiny SKILL.md files).
+ *   - findStaleDocs(projectRoot)   : root-level .md files that look like
+ *     historical artifacts (old version docs, sprint reports, test plans,
+ *     interview summaries, announcement guides).
+ *
+ * All detection is pattern-based with a hard allowlist ; no file is
+ * flagged without a named reason.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const SKILL_ALLOWLIST = new Set([
+  'byan-fact-check',
+  'byan-elo-trust',
+  'byan-merise-agile',
+  'byan-hermes-dispatch',
+  'byan-forge',
+  'byan-byan', // BYAN itself as a skill — core, never flag
+]);
+
+const SKILL_PATTERNS = [
+  { re: /(^|-)test(ing|-dynamic)?$/i, reason: 'test/placeholder agent (not a real BYAN capability)' },
+  { re: /^byan-byan-(v2|test)$/i, reason: 'versioned or test stub of BYAN itself' },
+  { re: /^byan-(claude|codex)$/i, reason: 'platform name (not an agent role)' },
+  { re: /^byan-skeptic$/i, reason: 'experimental agent not wired in menus' },
+];
+
+const DOC_ALLOWLIST = new Set([
+  'README.md',
+  'LICENSE',
+  'LICENSE.md',
+  'CHANGELOG.md',
+  'CONTRIBUTING.md',
+  'CODE_OF_CONDUCT.md',
+  'CLAUDE.md',
+  'GUIDE-UTILISATION.md',
+  'NOTES.md',
+]);
+
+const DOC_PATTERNS = [
+  { re: /^SPRINT\d+-.*\.md$/i, reason: 'sprint report' },
+  { re: /^BYAN-V\d+(\.\d+)*-.*\.md$/i, reason: 'old version snapshot doc' },
+  { re: /^CHANGELOG-v\d+(\.\d+)*\.md$/i, reason: 'versioned changelog (current is CHANGELOG.md)' },
+  { re: /^MIGRATION-.*\.md$/i, reason: 'migration guide for an older version' },
+  { re: /^README-BYAN-V\d+(\.\d+)*\.md$/i, reason: 'versioned README (current is README.md)' },
+  { re: /^API-BYAN-V\d+(\.\d+)*\.md$/i, reason: 'versioned API doc' },
+  { re: /^TEST-GUIDE-.*\.md$/i, reason: 'historical test guide' },
+  { re: /-MANUAL-TEST-PLAN\.md$/i, reason: 'manual test plan' },
+  { re: /-STATUS-REPORT\.md$/i, reason: 'status report' },
+  { re: /-COMPLETE\.md$/i, reason: 'completion report' },
+  { re: /-SUMMARY(\.txt|\.md)$/i, reason: 'summary artifact' },
+  { re: /-DELIVERY-SUMMARY\.md$/i, reason: 'delivery summary' },
+  { re: /^interview-summary-.*\.md$/i, reason: 'interview summary' },
+  { re: /^fd-.*\.md$/i, reason: 'forge-persona session artifact' },
+  { re: /^AGENT-LAUNCHER-DOC.*\.md$/i, reason: 'agent launcher legacy doc' },
+  { re: /^ANNOUNCEMENT-GUIDE-.*\.md$/i, reason: 'announcement guide for older version' },
+  { re: /^SESSION-RESUME-.*\.md$/i, reason: 'session resume artifact' },
+  { re: /^BYAN-V2-.*\.md$/i, reason: 'v2-specific doc (keep only if still referenced)' },
+  { re: /^BMAD-QUICK-REFERENCE.*\.md$/i, reason: 'legacy quick reference' },
+  { re: /^100-PERCENT-.*\.md$/i, reason: 'milestone completion report' },
+];
+
+function readFrontmatter(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const m = raw.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!m) return {};
+    const out = {};
+    for (const line of m[1].split('\n')) {
+      const kv = line.match(/^(\w[\w-]*)\s*:\s*(.*)$/);
+      if (kv) out[kv[1]] = kv[2].replace(/^["']|["']$/g, '').trim();
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+
+function findStaleSkills(skillsDir) {
+  if (!fs.existsSync(skillsDir)) return [];
+  const found = [];
+  const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    if (SKILL_ALLOWLIST.has(e.name)) continue;
+
+    const skillFile = path.join(skillsDir, e.name, 'SKILL.md');
+    if (!fs.existsSync(skillFile)) continue;
+
+    const reasons = [];
+
+    for (const { re, reason } of SKILL_PATTERNS) {
+      if (re.test(e.name)) reasons.push(reason);
+    }
+
+    const size = fs.statSync(skillFile).size;
+    if (size < 200) reasons.push(`tiny SKILL.md (${size} bytes — likely placeholder stub)`);
+
+    const fm = readFrontmatter(skillFile);
+    if (!fm.description || fm.description.length < 40) {
+      reasons.push('missing or too-short description in frontmatter');
+    }
+
+    if (reasons.length > 0) {
+      found.push({
+        path: path.join(skillsDir, e.name),
+        name: e.name,
+        reasons,
+        size,
+      });
+    }
+  }
+  return found;
+}
+
+function findStaleDocs(projectRoot) {
+  if (!fs.existsSync(projectRoot)) return [];
+  const found = [];
+  const entries = fs.readdirSync(projectRoot, { withFileTypes: true });
+  for (const e of entries) {
+    if (!e.isFile()) continue;
+    if (!/\.(md|txt)$/i.test(e.name)) continue;
+    if (DOC_ALLOWLIST.has(e.name)) continue;
+
+    const reasons = [];
+    for (const { re, reason } of DOC_PATTERNS) {
+      if (re.test(e.name)) reasons.push(reason);
+    }
+
+    if (reasons.length > 0) {
+      const p = path.join(projectRoot, e.name);
+      const size = fs.statSync(p).size;
+      found.push({ path: p, name: e.name, reasons, size });
+    }
+  }
+  return found;
+}
+
+module.exports = {
+  SKILL_ALLOWLIST,
+  SKILL_PATTERNS,
+  DOC_ALLOWLIST,
+  DOC_PATTERNS,
+  findStaleSkills,
+  findStaleDocs,
+  readFrontmatter,
+};

package/install/lib/cleanup/executor.js

@@ -0,0 +1,72 @@
+/**
+ * BYAN cleanup executor.
+ *
+ * Two removal modes :
+ *   - archive(items, archiveDir) : move each item into a timestamped
+ *     subdir of archiveDir (reversible).
+ *   - deleteHard(items)          : rm -rf each item (irreversible).
+ *
+ * Both return per-item results so the caller can print a clean summary.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function timestampDir() {
+  const d = new Date();
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+}
+
+function archive(items, { archiveRoot, now = new Date() } = {}) {
+  if (!Array.isArray(items) || items.length === 0) return { moved: [], errors: [] };
+
+  const stamp =
+    now instanceof Date
+      ? (() => {
+          const pad = (n) => String(n).padStart(2, '0');
+          return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+        })()
+      : String(now);
+
+  const baseRoot = archiveRoot || path.join('_byan-output', 'archive');
+  const dest = path.join(baseRoot, stamp);
+  fs.mkdirSync(dest, { recursive: true });
+
+  const moved = [];
+  const errors = [];
+  for (const item of items) {
+    const src = item.path || item;
+    const name = path.basename(src);
+    const target = path.join(dest, name);
+    try {
+      fs.renameSync(src, target);
+      moved.push({ from: src, to: target });
+    } catch (err) {
+      errors.push({ path: src, error: err.message });
+    }
+  }
+  return { moved, errors, archiveDir: dest };
+}
+
+function deleteHard(items) {
+  if (!Array.isArray(items) || items.length === 0) return { deleted: [], errors: [] };
+  const deleted = [];
+  const errors = [];
+  for (const item of items) {
+    const src = item.path || item;
+    try {
+      fs.rmSync(src, { recursive: true, force: true });
+      deleted.push(src);
+    } catch (err) {
+      errors.push({ path: src, error: err.message });
+    }
+  }
+  return { deleted, errors };
+}
+
+module.exports = {
+  archive,
+  deleteHard,
+  timestampDir,
+};