@gredescerber/agent-crew 0.0.0-stage → 0.6.0

package/src/commands/compliance.js

@@ -0,0 +1,109 @@
+// crew compliance check | disclosure — compliance with the event rules (event mode).
+// Event rules live in events/<name>.json (start, end, ai_allowed, team_members, ...).
+import { writeFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ok, warn, fail } from '../core/output.js';
+import { git, run } from '../core/exec.js';
+import { loadConfig, loadEvent, HARNESS_ROOT } from '../core/config.js';
+
+/** Commits with changes, excluding service merge commits: author date, author, Agent trailer. */
+export function commits(root) {
+  const out = git(['log', '--no-merges', '--format=%H%x1f%aI%x1f%ae%x1f%(trailers:key=Agent,valueonly,separator=%x2c)%x1e'], { cwd: root, allowFail: true });
+  if (out.code !== 0) return [];
+  return out.stdout.split('\x1e').map((r) => r.trim()).filter(Boolean).map((r) => {
+    const [sha, date, email, agent] = r.split('\x1f');
+    return { sha, date, email, agent: (agent ?? '').trim() || null };
+  });
+}
+
+/** Pure check function — the tests run it too. */
+export function evaluate(event, list, prAuthors = []) {
+  const problems = [];
+  const warnings = [];
+  const start = Date.parse(event.start);
+  const end = Date.parse(event.end);
+  const early = list.filter((c) => Date.parse(c.date) < start);
+  const late = list.filter((c) => Date.parse(c.date) > end);
+  if (early.length) problems.push(`commits before the start: ${early.length} (first ${early.at(-1).sha.slice(0, 7)})`);
+  if (late.length) problems.push(`commits after the end: ${late.length}`);
+  const agentCommits = list.filter((c) => c.agent && c.agent !== 'human');
+  if (event.ai_allowed === false && agentCommits.length) problems.push(`AI is forbidden, but agent commits: ${agentCommits.length}`);
+  const team = new Set((event.team_members ?? []).map((s) => s.toLowerCase()));
+  if (team.size) {
+    const outsiders = [...new Set(prAuthors.filter((a) => !team.has(a.toLowerCase())))];
+    if (outsiders.length) problems.push(`PRs from humans outside the team: ${outsiders.join(', ')}`);
+  } else {
+    warnings.push('team_members is empty — team membership is not checked');
+  }
+  const noTrailer = list.filter((c) => !c.agent && Date.parse(c.date) >= start);
+  if (noTrailer.length) problems.push(`commits without the Agent trailer: ${noTrailer.length} (use crew commit)`);
+  return { problems, warnings, stats: { commits: list.length, agent_commits: agentCommits.length } };
+}
+
+const check = {
+  name: 'compliance check',
+  summary: 'Event mode: check the repo against the event rules (time window, team membership, AI use)',
+  usesCwd: true,
+  args: [],
+  run({ cwd } = {}) {
+    const { config, root } = loadConfig(cwd);
+    const event = loadEvent(config, root);
+    if (!event) {
+      return warn('No event configured — nothing to check', {
+        next_actions: ['fill in events/event.json and set "event": "events/event.json" in crew.config.json'],
+      });
+    }
+    const pr = run('gh', ['pr', 'list', '--state', 'all', '--limit', '500', '--json', 'author'], { cwd: root, allowFail: true });
+    const authors = pr.code === 0 ? JSON.parse(pr.stdout || '[]').map((p) => p.author?.login).filter(Boolean) : [];
+    const res = evaluate(event, commits(root), authors);
+    if (res.problems.length) {
+      return fail('compliance_violation', `Violations: ${res.problems.length}`, {
+        cause_hint: res.problems.join('; '),
+        stop_when: 'always — a human decides this; agents do not rewrite history',
+        next_actions: ['tell the team captain', 'do not rewrite git history'],
+        artifacts: res,
+      });
+    }
+    return (res.warnings.length ? warn : ok)(`Compliance with the rules of "${event.name}": OK`, { artifacts: res });
+  },
+};
+
+const disclosure = {
+  name: 'compliance disclosure',
+  summary: 'Generate DISCLOSURE.md: which tools and agents were used',
+  agent: false,
+  args: [],
+  run() {
+    const { config, root } = loadConfig();
+    const event = loadEvent(config, root) ?? {};
+    const list = commits(root);
+    const byAgent = {};
+    for (const c of list) byAgent[c.agent ?? 'unknown'] = (byAgent[c.agent ?? 'unknown'] ?? 0) + 1;
+    const version = JSON.parse(readFileSync(join(HARNESS_ROOT, 'package.json'), 'utf8')).version;
+    const md = [
+      '# Disclosure',
+      '',
+      `Event: **${event.name ?? '—'}** (${event.start ?? '?'} — ${event.end ?? '?'})`,
+      '',
+      '## Tools',
+      `- [agent-crew](${config.harness_url ?? 'https://github.com/<org>/agent-crew'}) v${version} — an open-source tool for coordinating agents (rules, templates, CLI). Contains no product code.`,
+      `- AI agents: ${config.hosts.join(', ')}${config.ecc?.enabled !== false ? '; ECC plugin for Claude Code' : ''}.`,
+      `- Stack generators: ${(config.scaffold ?? []).map((s) => '`' + s + '`').join(', ') || '—'}`,
+      '',
+      '## What was done before the event',
+      '- Only tooling and public dependencies. All product code was written during the event.',
+      '',
+      '## Commit provenance',
+      '| Agent / author | Commits |',
+      '|---|---|',
+      ...Object.entries(byAgent).map(([a, n]) => `| ${a} | ${n} |`),
+      '',
+      'Every agent commit carries an `Agent:` trailer and a link to the task (`Issue: #N`).',
+      '',
+    ].join('\n');
+    writeFileSync(join(root, 'DISCLOSURE.md'), md);
+    return ok('DISCLOSURE.md created', { artifacts: { path: join(root, 'DISCLOSURE.md'), by_agent: byAgent } });
+  },
+};
+
+export default [check, disclosure];

package/src/commands/digest.js

@@ -0,0 +1,64 @@
+// crew digest [--post] — team status without an LLM: what waits for a human, stale leases, PRs, open questions,
+// idle members. --post keeps it in one pinned issue (label crew:digest); the sweep job runs it every 15 minutes,
+// so nobody has to keep an agent session polling the repo.
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ok, fail } from '../core/output.js';
+import { gh, ghJson } from '../core/exec.js';
+import { loadConfig } from '../core/config.js';
+import { listIssues } from '../core/issues.js';
+import { DEFAULT_PRD, parsePrd } from '../core/prd.js';
+import { QUESTION_LABEL } from '../core/questions.js';
+import { digestModel, renderDigest, DIGEST_LABEL, DIGEST_TITLE } from '../core/digest.js';
+
+const PR_FIELDS = 'number,title,body,headRefOid,createdAt,isDraft,author,labels,comments,statusCheckRollup,mergeable,isCrossRepository,autoMergeRequest';
+
+/** Live data through gh (tests pass deps.data instead). */
+export function githubData(root) {
+  const p = join(root, DEFAULT_PRD);
+  return {
+    issues: listIssues({ limit: 500 }),
+    prs: ghJson(['pr', 'list', '--state', 'open', '--limit', '50', '--json', PR_FIELDS], { cwd: root, allowFail: true }) ?? [],
+    questions: ghJson(['issue', 'list', '--state', 'open', '--label', QUESTION_LABEL, '--limit', '100', '--json', 'number,title,body,labels,assignees,createdAt'], { cwd: root, allowFail: true }) ?? [],
+    team: existsSync(p) ? parsePrd(readFileSync(p, 'utf8')).team : null,
+  };
+}
+
+/** Create the pinned digest issue once, then edit its body. -> { issue, created } | { error } */
+export function postDigest(body, { root = '.', gh: ghf = gh, ghJson: ghj = ghJson } = {}) {
+  const found = ghj(['issue', 'list', '--state', 'open', '--label', DIGEST_LABEL, '--limit', '1', '--json', 'number'], { cwd: root, allowFail: true }) ?? [];
+  if (found[0]?.number) {
+    const r = ghf(['issue', 'edit', String(found[0].number), '--body-file', '-'], { cwd: root, allowFail: true, input: body });
+    return r.code === 0 ? { issue: found[0].number, created: false } : { error: (r.stderr || r.stdout || '').split('\n')[0] || 'issue edit failed' };
+  }
+  const r = ghf(['issue', 'create', '--title', DIGEST_TITLE, '--label', DIGEST_LABEL, '--body-file', '-'], { cwd: root, allowFail: true, input: body });
+  const number = Number(/\/issues\/(\d+)/.exec(r.stdout ?? '')?.[1]);
+  if (r.code !== 0 || !number) return { error: (r.stderr || r.stdout || '').split('\n')[0] || 'issue create failed' };
+  ghf(['issue', 'pin', String(number)], { cwd: root, allowFail: true });
+  return { issue: number, created: true };
+}
+
+export default {
+  name: 'digest',
+  summary: 'Team status without an LLM: needs-a-human, stale leases, PRs, open questions, idle members; --post updates the pinned issue',
+  args: [{ name: 'post', type: 'boolean', description: 'create or update the pinned "crew digest" issue (the sweep job does this)' }],
+  run({ post = false } = {}, deps = {}) {
+    const { config, root } = deps.config ? { config: deps.config, root: '.' } : loadConfig();
+    const data = deps.data ?? githubData(root);
+    const now = deps.now ?? Date.now();
+    const model = digestModel({ ...data, config, now });
+    const markdown = renderDigest(model, { now });
+    let posted = null;
+    if (post) {
+      posted = postDigest(markdown, { root, ...(deps.gh ? { gh: deps.gh } : {}), ...(deps.ghJson ? { ghJson: deps.ghJson } : {}) });
+      if (posted.error) {
+        return fail('gh_failed', 'Could not update the digest issue', { cause_hint: posted.error, retry: 'crew labels sync (the crew:digest label may be missing), then crew digest --post' });
+      }
+    }
+    const c = model.counts;
+    return ok(`${c.human} need a human, ${c.stale} stale, ${c.prs} PRs waiting, ${c.idle} idle${posted ? `; digest #${posted.issue}${posted.created ? ' created and pinned' : ' updated'}` : ''}`, {
+      status: c.human || c.stale ? 'warning' : 'success',
+      artifacts: { counts: c, sections: model.sections, markdown, issue: posted?.issue ?? null },
+    });
+  },
+};

package/src/commands/doctor.js

@@ -0,0 +1,48 @@
+// crew doctor — check that the machine is ready to work.
+import { ok, fail } from '../core/output.js';
+import { run } from '../core/exec.js';
+import { loadConfig, agentId } from '../core/config.js';
+import { LOCAL_VERSION, updateHint } from '../core/version.js';
+
+const probe = (cmd, args) => {
+  const r = run(cmd, args, { allowFail: true });
+  return r.code === 0 ? (r.stdout || r.stderr).split('\n')[0] : null;
+};
+
+export default {
+  name: 'doctor',
+  summary: 'Check the environment: node, git, gh (auth), claude, codex, project config',
+  args: [],
+  run() {
+    const { config, path } = loadConfig();
+    const winCmd = process.platform === 'win32';
+    const tool = (name, args) => probe(name, args) ?? (winCmd ? probe('cmd', ['/c', name, ...args]) : null);
+    const items = {
+      node: process.version,
+      git: tool('git', ['--version']),
+      gh: tool('gh', ['--version']),
+      gh_auth: run('gh', ['auth', 'status'], { allowFail: true }).code === 0 ? 'ok' : null,
+      config: path ?? null,
+      agent_id: agentId(),
+    };
+    for (const h of config.hosts ?? []) items[h] = tool(h, ['--version']);
+    const required = ['git', 'gh', 'gh_auth'];
+    const missing = required.filter((k) => !items[k]);
+    const hostsMissing = (config.hosts ?? []).filter((h) => !items[h]);
+    if (missing.length) {
+      return fail('env_missing', `Missing: ${missing.join(', ')}`, {
+        cause_hint: missing.includes('gh_auth') ? 'gh is not authenticated' : 'tool is not installed',
+        retry: missing.includes('gh_auth') ? 'gh auth login' : 'install it and re-run crew doctor',
+        artifacts: items,
+      });
+    }
+    items.crew = LOCAL_VERSION;
+    const hint = updateHint();
+    const notes = [hostsMissing.length ? `agents missing: ${hostsMissing.join(', ')}` : null, hint ? `crew is outdated (${LOCAL_VERSION})` : null].filter(Boolean);
+    return ok(notes.length ? `Environment OK, but ${notes.join('; ')}` : 'Environment ready', {
+      status: notes.length ? 'warning' : 'success',
+      artifacts: items,
+      next_actions: [...(hint ? [hint] : []), ...(path ? ['crew status'] : ['crew init <dir> — create a project'])],
+    });
+  },
+};