rigjs 3.0.33 → 4.0.2

package/lib/crew/role.ts

@@ -0,0 +1,121 @@
+import fs from 'fs';
+import path from 'path';
+import { crewPaths } from './paths';
+
+export interface CrewRoleDefinition {
+  name: string;
+  title: string;
+  folder: string;
+  description?: string;
+  agent?: string;
+  defaultExecutor?: string;
+  promptPath?: string;
+  configPath?: string;
+  builtIn?: boolean;
+}
+
+export const BUILTIN_ROLE_NAMES = ['lead', 'designer', 'pm', 'coder', 'tester', 'researcher'];
+
+const BUILTIN_ROLES: CrewRoleDefinition[] = [
+  { name: 'lead', title: 'Lead', folder: 'Lead', description: 'Primary user-facing coordinator.', builtIn: true },
+  { name: 'designer', title: 'Designer', folder: 'Designer', description: 'Interaction, UX, information architecture, and visual review.', builtIn: true },
+  { name: 'pm', title: 'PM', folder: 'PM', description: 'PRD generation, requirements review, scope, and acceptance criteria.', builtIn: true },
+  { name: 'coder', title: 'Coder', folder: 'Coder', description: 'Implementation work when no project owner is more specific.', builtIn: true },
+  { name: 'tester', title: 'Tester', folder: 'Tester', description: 'Verification, test planning, and PRD-scoped E2E checks.', builtIn: true },
+  { name: 'researcher', title: 'Researcher', folder: 'Researcher', description: 'Source-backed research and durable reports.', builtIn: true },
+];
+
+export function normalizeRoleName(input: string): string {
+  const name = input.trim().toLowerCase().replace(/\s+/g, '-');
+  if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+    throw new Error(`invalid role name "${input}". Use lowercase letters, numbers, and hyphens.`);
+  }
+  return name;
+}
+
+export function normalizeRoleNames(names: string[]): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const raw of names) {
+    const name = normalizeRoleName(raw);
+    if (seen.has(name)) continue;
+    seen.add(name);
+    out.push(name);
+  }
+  return out;
+}
+
+export function roleFolderName(name: string): string {
+  return titleFromRoleName(name).replace(/[^A-Za-z0-9]/g, '');
+}
+
+export function roleConfigDir(name: string): string {
+  return path.join(crewPaths.rolesDir, normalizeRoleName(name));
+}
+
+export function roleConfigPath(name: string): string {
+  return path.join(roleConfigDir(name), 'role.json');
+}
+
+export function loadGlobalRoleNames(): string[] {
+  return loadCustomRoleDefinitions().map(r => r.name);
+}
+
+export function roleDefinitionsForCrew(crew: { roles?: string[] }): CrewRoleDefinition[] {
+  const known = new Map<string, CrewRoleDefinition>();
+  for (const role of BUILTIN_ROLES) known.set(role.name, role);
+  for (const role of loadCustomRoleDefinitions()) known.set(role.name, role);
+  const names = normalizeRoleNames(crew.roles && crew.roles.length ? crew.roles : BUILTIN_ROLE_NAMES);
+  return names.map(name => known.get(name) || fallbackRole(name));
+}
+
+export function loadCustomRoleDefinitions(): CrewRoleDefinition[] {
+  if (!fs.existsSync(crewPaths.rolesDir)) return [];
+  const roles: CrewRoleDefinition[] = [];
+  for (const entry of fs.readdirSync(crewPaths.rolesDir)) {
+    const cfg = path.join(crewPaths.rolesDir, entry, 'role.json');
+    if (!fs.existsSync(cfg)) continue;
+    try {
+      const raw = JSON.parse(fs.readFileSync(cfg, 'utf8')) as Partial<CrewRoleDefinition>;
+      if (!raw.name) continue;
+      const name = normalizeRoleName(raw.name);
+      roles.push({
+        name,
+        title: raw.title || titleFromRoleName(name),
+        folder: raw.folder || path.join('Roles', name),
+        description: raw.description,
+        agent: raw.agent,
+        defaultExecutor: raw.defaultExecutor,
+        promptPath: raw.promptPath || path.join(roleConfigDir(name), 'prompt.md'),
+        configPath: cfg,
+      });
+    } catch {
+      // Invalid role configs are ignored by passive loaders; `rig crew role show`
+      // surfaces parse errors when the user inspects a specific role.
+    }
+  }
+  return roles.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function roleByName(name: string, crew?: { roles?: string[] }): CrewRoleDefinition | undefined {
+  const normalized = normalizeRoleName(name);
+  const defs = crew ? roleDefinitionsForCrew(crew) : [...BUILTIN_ROLES, ...loadCustomRoleDefinitions()];
+  return defs.find(r => r.name === normalized);
+}
+
+export function titleFromRoleName(name: string): string {
+  return name
+    .split('-')
+    .filter(Boolean)
+    .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(' ');
+}
+
+function fallbackRole(name: string): CrewRoleDefinition {
+  return {
+    name,
+    title: titleFromRoleName(name),
+    folder: path.join('Roles', name),
+    description: 'Custom role without a global role.json definition.',
+  };
+}

package/lib/crew/roleCommand.ts

@@ -0,0 +1,150 @@
+import fs from 'fs';
+import path from 'path';
+import print from '../print';
+import { requireCrew, resolveCrew, shortPath } from './config';
+import { ensureCrewVault } from './vault';
+import {
+  BUILTIN_ROLE_NAMES,
+  loadGlobalRoleNames,
+  normalizeRoleName,
+  roleByName,
+  roleConfigDir,
+  roleConfigPath,
+  roleDefinitionsForCrew,
+  titleFromRoleName,
+} from './role';
+
+interface RoleAddOpts {
+  from: string;
+  title?: string;
+  summary?: string;
+  agent?: string;
+  executor?: string;
+  force?: boolean;
+  crew?: string;
+}
+
+interface RoleListOpts { crew?: string; }
+interface RoleShowOpts { crew?: string; }
+
+export function roleAdd(nameInput: string, opts: RoleAddOpts): void {
+  const name = normalizeRoleName(nameInput);
+  const existing = roleByName(name);
+  if (existing && existing.builtIn) {
+    print.error(`cannot override built-in role: ${name}`);
+    process.exit(1);
+  }
+  if (!opts.from) {
+    print.error('missing --from <file>');
+    process.exit(1);
+  }
+  const source = path.resolve(opts.from);
+  if (!fs.existsSync(source)) {
+    print.error(`role description file not found: ${source}`);
+    process.exit(1);
+  }
+  const dir = roleConfigDir(name);
+  const cfg = roleConfigPath(name);
+  if (fs.existsSync(cfg) && !opts.force) {
+    print.error(`role already exists: ${name}. Pass --force to update it.`);
+    process.exit(1);
+  }
+
+  const body = fs.readFileSync(source, 'utf8');
+  const now = new Date().toISOString();
+  const previous = readRoleConfig(cfg);
+  const role = {
+    name,
+    title: opts.title || markdownTitle(body) || previous?.title || titleFromRoleName(name),
+    folder: previous?.folder || `Roles/${name}`,
+    description: opts.summary || firstParagraph(body) || previous?.description || '',
+    agent: opts.agent || previous?.agent,
+    defaultExecutor: normalizeExecutor(opts.executor || previous?.defaultExecutor),
+    promptPath: path.join(dir, 'prompt.md'),
+    sourcePath: source,
+    createdAt: previous?.createdAt || now,
+    updatedAt: now,
+  };
+
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'prompt.md'), body, 'utf8');
+  fs.writeFileSync(path.join(dir, 'source.md'), sourceHeader(source) + body, 'utf8');
+  fs.writeFileSync(cfg, JSON.stringify(role, null, 2) + '\n', 'utf8');
+
+  print.succeed(`role "${name}" saved: ${shortPath(cfg)}`);
+  const crew = opts.crew ? requireCrew(opts.crew) : resolveCrew();
+  if (crew) {
+    ensureCrewVault(requireCrew(crew.name));
+    print.info(`role "${name}" is available to crew "${crew.name}"`);
+  } else {
+    print.info('no crew configured yet; the role will load after `rig crew init`.');
+  }
+}
+
+export function roleList(opts: RoleListOpts): void {
+  const crew = opts.crew ? requireCrew(opts.crew) : undefined;
+  const roles = crew
+    ? roleDefinitionsForCrew(crew)
+    : roleDefinitionsForCrew({ roles: [...BUILTIN_ROLE_NAMES, ...loadGlobalRoleNames()] });
+  // eslint-disable-next-line no-console
+  console.log('ROLE  TITLE  AGENT  EXECUTOR  FOLDER  CONFIG');
+  // eslint-disable-next-line no-console
+  console.log('----  -----  -----  --------  ------  ------');
+  for (const role of roles) {
+    // eslint-disable-next-line no-console
+    console.log(`${role.name}  ${role.title}  ${role.agent || '-'}  ${role.defaultExecutor || '-'}  ${role.folder}  ${role.configPath ? shortPath(role.configPath) : 'built-in'}`);
+  }
+}
+
+export function roleShow(nameInput: string, opts: RoleShowOpts): void {
+  const crew = opts.crew ? requireCrew(opts.crew) : undefined;
+  const role = roleByName(nameInput, crew);
+  if (!role) {
+    print.error(`unknown role: ${nameInput}`);
+    process.exit(1);
+  }
+  print.info(`role: ${role.name}`);
+  // eslint-disable-next-line no-console
+  console.log(`title: ${role.title}`);
+  // eslint-disable-next-line no-console
+  console.log(`folder: ${role.folder}`);
+  // eslint-disable-next-line no-console
+  console.log(`agent: ${role.agent || '-'}`);
+  // eslint-disable-next-line no-console
+  console.log(`executor: ${role.defaultExecutor || '-'}`);
+  // eslint-disable-next-line no-console
+  console.log(`config: ${role.configPath ? shortPath(role.configPath) : 'built-in'}`);
+  // eslint-disable-next-line no-console
+  console.log(`prompt: ${role.promptPath ? shortPath(role.promptPath) : '-'}`);
+  if (role.description) {
+    // eslint-disable-next-line no-console
+    console.log(`description: ${role.description}`);
+  }
+}
+
+function normalizeExecutor(value?: string): string | undefined {
+  if (!value) return undefined;
+  if (value === 'claude' || value === 'codex' || value === 'pi') return value;
+  print.error(`unknown executor: ${value}. Expected claude, codex, or pi.`);
+  process.exit(1);
+}
+
+function readRoleConfig(file: string): any | undefined {
+  if (!fs.existsSync(file)) return undefined;
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return undefined; }
+}
+
+function markdownTitle(text: string): string | undefined {
+  const line = text.split(/\r?\n/).find(l => /^#\s+/.test(l));
+  return line ? line.replace(/^#\s+/, '').trim() : undefined;
+}
+
+function firstParagraph(text: string): string | undefined {
+  const lines = text.split(/\r?\n/).map(l => l.trim());
+  const paragraph = lines.find(l => l && !l.startsWith('#') && !l.startsWith('---'));
+  return paragraph ? paragraph.slice(0, 240) : undefined;
+}
+
+function sourceHeader(source: string): string {
+  return `<!-- Imported from ${source} at ${new Date().toISOString()} -->\n\n`;
+}

package/lib/crew/state.ts

@@ -0,0 +1,19 @@
+import fs from 'fs';
+import { crewPaths } from './paths';
+import { CrewEntry } from './config';
+import { CrewTask, summarize } from './task';
+
+export function writeCrewState(crew: CrewEntry, tasks: CrewTask[]): void {
+  fs.mkdirSync(crewPaths.home, { recursive: true });
+  const summary = summarize(tasks);
+  const data = {
+    updatedAt: new Date().toISOString(),
+    crew: crew.name,
+    vault: crew.vault,
+    root: crew.root,
+    summary,
+    tasks,
+  };
+  fs.writeFileSync(crewPaths.state, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+

package/lib/crew/status.ts

@@ -0,0 +1,27 @@
+import print from '../print';
+import { requireCrew, shortPath } from './config';
+import { scanTasks, openInboxTasks, summarize } from './task';
+import { writeCrewState } from './state';
+
+interface StatusOpts { crew?: string; json?: boolean; }
+
+export default function crewStatus(opts: StatusOpts): void {
+  const crew = requireCrew(opts.crew);
+  const tasks = scanTasks(crew);
+  const inbox = openInboxTasks(crew);
+  const s = summarize(tasks);
+  writeCrewState(crew, tasks);
+  if (opts.json) {
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify({ ok: true, crew: crew.name, vault: crew.vault, summary: s, inbox: inbox.length }, null, 2));
+    return;
+  }
+  print.info(`crew: ${crew.name}`);
+  // eslint-disable-next-line no-console
+  console.log(`vault: ${shortPath(crew.vault)}`);
+  // eslint-disable-next-line no-console
+  console.log(`tasks: ${s.done}/${s.total} done, ${s.open} open, ${s.blocked} blocked, ${s.doing} doing`);
+  // eslint-disable-next-line no-console
+  console.log(`inbox: ${inbox.length} open`);
+}
+

package/lib/crew/stub.ts

@@ -0,0 +1,9 @@
+import print from '../print';
+
+export default function crewStub(name: string): () => void {
+  return () => {
+    print.warn(`rig crew ${name} is not implemented yet.`);
+    print.info('Current MVP supports init, status, inbox, board, sync, doctor, ask, and project add/list/status.');
+  };
+}
+

package/lib/crew/sync.ts

@@ -0,0 +1,15 @@
+import print from '../print';
+import { requireCrew } from './config';
+import { scanTasks, summarize } from './task';
+import { writeCrewState } from './state';
+
+interface SyncOpts { crew?: string; }
+
+export default function crewSync(opts: SyncOpts): void {
+  const crew = requireCrew(opts.crew);
+  const tasks = scanTasks(crew);
+  writeCrewState(crew, tasks);
+  const s = summarize(tasks);
+  print.succeed(`crew state synced: ${s.done}/${s.total} tasks done`);
+}
+

package/lib/crew/task.ts

@@ -0,0 +1,92 @@
+import fs from 'fs';
+import path from 'path';
+import { CrewEntry } from './config';
+import { rootPath } from './vault';
+import { roleDefinitionsForCrew } from './role';
+
+export interface CrewTask {
+  id?: string;
+  text: string;
+  done: boolean;
+  file: string;
+  line: number;
+  scope: string;
+  fields: { [key: string]: string };
+}
+
+export interface CrewSummary {
+  total: number;
+  done: number;
+  open: number;
+  blocked: number;
+  doing: number;
+}
+
+export function scanTasks(crew: CrewEntry): CrewTask[] {
+  const files = taskFiles(crew);
+  const tasks: CrewTask[] = [];
+  for (const item of files) tasks.push(...parseTasks(item.file, item.scope));
+  return tasks;
+}
+
+export function parseTasks(file: string, scope: string): CrewTask[] {
+  if (!fs.existsSync(file)) return [];
+  const lines = fs.readFileSync(file, 'utf8').split(/\r?\n/);
+  const tasks: CrewTask[] = [];
+  for (let i = 0; i < lines.length; i++) {
+    const parsed = parseTaskLine(lines[i]);
+    if (parsed) tasks.push({ ...parsed, file, line: i + 1, scope });
+  }
+  return tasks;
+}
+
+export function summarize(tasks: CrewTask[]): CrewSummary {
+  let done = 0, blocked = 0, doing = 0;
+  for (const t of tasks) {
+    if (t.done) done++;
+    const status = (t.fields.status || '').toLowerCase();
+    if (status === 'blocked') blocked++;
+    if (status === 'doing' || status === 'in-progress') doing++;
+  }
+  return { total: tasks.length, done, open: tasks.length - done, blocked, doing };
+}
+
+export function openInboxTasks(crew: CrewEntry): CrewTask[] {
+  return parseTasks(rootPath(crew, 'Inbox.md'), 'inbox').filter(t => !t.done);
+}
+
+export function taskProgress(tasks: CrewTask[]): number {
+  if (tasks.length === 0) return 0;
+  return Math.round((summarize(tasks).done / tasks.length) * 100);
+}
+
+function parseTaskLine(line: string): Omit<CrewTask, 'file' | 'line' | 'scope'> | undefined {
+  const match = line.match(/^\s*-\s+\[([ xX-])\]\s+(.+)$/);
+  if (!match) return undefined;
+  const done = match[1].toLowerCase() === 'x';
+  const raw = match[2].trim();
+  const fields: { [key: string]: string } = {};
+  const fieldRe = /\[([A-Za-z0-9_-]+)::\s*([^\]]+)\]/g;
+  let f: RegExpExecArray | null;
+  while ((f = fieldRe.exec(raw))) fields[f[1]] = f[2].trim();
+  const idMatch = raw.match(/\b(?:AT|D|Q|A|R)-\d{6}-\d{3}\b/);
+  return { id: idMatch ? idMatch[0] : undefined, text: raw, done, fields };
+}
+
+function taskFiles(crew: CrewEntry): { file: string; scope: string }[] {
+  const files = [
+    { file: rootPath(crew, 'Inbox.md'), scope: 'inbox' },
+    ...roleDefinitionsForCrew(crew).map(role => ({
+      file: rootPath(crew, path.join(role.folder, 'Tasks.md')),
+      scope: `role:${role.name}`,
+    })),
+  ];
+  const projectsDir = rootPath(crew, 'Projects');
+  if (fs.existsSync(projectsDir)) {
+    for (const name of fs.readdirSync(projectsDir)) {
+      const file = path.join(projectsDir, name, 'Tasks.md');
+      if (fs.existsSync(file)) files.push({ file, scope: `project:${name}` });
+    }
+  }
+  return files.filter(item => fs.existsSync(item.file));
+}