@ijfw/memory-server 1.3.0 → 1.4.1

package/src/swarm/worktree.js

@@ -0,0 +1,239 @@
+// Conservative git worktree support for prepared swarm tasks.
+//
+// This module never dispatches agents and never auto-resolves merge conflicts.
+// It creates isolated worktrees for code-heavy tasks after the task lifecycle
+// has prepared/started them.
+
+import { existsSync, mkdirSync, realpathSync, rmSync } from 'node:fs';
+import { isAbsolute, join, relative, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { appendBlackboardEvent, listBlackboardTasks, updateBlackboardTask } from '../blackboard.js';
+import { createCheckpoint } from '../recovery/checkpoint.js';
+
+export function createTaskWorktree(projectRoot, taskId, options = {}) {
+  const root = resolve(projectRoot);
+  const task = findTask(root, taskId);
+  if (!task.ok) return task;
+  if (task.task.status !== 'in_progress' && !options.allowReady) {
+    return { ok: false, error: 'task-not-in-progress', task: task.task };
+  }
+  if (!options.force && !isCodeHeavyTask(task.task)) return { ok: false, error: 'non-code-task', task: task.task };
+  if (!isGitRepo(root)) return { ok: false, error: 'not-git-repo' };
+
+  const dirty = git(root, ['status', '--porcelain']);
+  if (dirty.status !== 0) return { ok: false, error: 'git-status-unavailable', stderr: dirty.stderr };
+  const dirtyUserFiles = dirtyLines(dirty.stdout);
+  if (dirtyUserFiles.length && !options.allowDirty) {
+    return { ok: false, error: 'dirty-worktree', detail: dirtyUserFiles };
+  }
+
+  const baseRef = options.baseRef || 'HEAD';
+  const worktreeDir = join(root, '.ijfw', 'worktrees');
+  const worktreePath = join(worktreeDir, safeTaskId(taskId));
+  if (existsSync(worktreePath)) return { ok: false, error: 'worktree-exists', path: worktreePath };
+  mkdirSync(worktreeDir, { recursive: true, mode: 0o700 });
+
+  createCheckpoint(root, 'before-worktree-create', { actor: 'ijfw', message: taskId });
+  const branch = options.branch || `ijfw/${safeTaskId(taskId)}`;
+  const result = git(root, ['worktree', 'add', '-b', branch, worktreePath, baseRef]);
+  if (result.status !== 0) return { ok: false, error: 'worktree-add-failed', stderr: result.stderr, stdout: result.stdout };
+
+  const updated = updateBlackboardTask(root, taskId, {
+    worktree: { path: worktreePath, branch, base_ref: baseRef, status: 'created' },
+  });
+  appendBlackboardEvent(root, {
+    type: 'worktree.created',
+    actor: 'ijfw',
+    task_id: taskId,
+    artifact_ids: task.task.artifact_ids || [],
+    message: worktreePath,
+    data: { branch, baseRef },
+  });
+  return { ok: true, task: updated.task, path: worktreePath, branch };
+}
+
+export function listTaskWorktrees(projectRoot) {
+  const root = resolve(projectRoot);
+  const tasks = (listBlackboardTasks(root).tasks || []).filter((task) => task.worktree);
+  return {
+    ok: true,
+    worktrees: tasks.map((task) => ({
+      task_id: task.id,
+      path: task.worktree.path,
+      branch: task.worktree.branch,
+      status: task.worktree.status,
+    })),
+  };
+}
+
+export function integrateTaskWorktree(projectRoot, taskId, options = {}) {
+  const root = resolve(projectRoot);
+  const task = findTask(root, taskId);
+  if (!task.ok) return task;
+  const wt = task.task.worktree;
+  if (!wt?.path) return { ok: false, error: 'no-worktree', task: task.task };
+  const validation = validateTaskWorktree(root, wt);
+  if (!validation.ok) return validation;
+  if (!existsSync(validation.path)) return { ok: false, error: 'worktree-missing', path: validation.path };
+
+  const wtDirty = git(validation.path, ['status', '--porcelain']);
+  if (wtDirty.status !== 0) return { ok: false, error: 'worktree-status-unavailable', stderr: wtDirty.stderr };
+  if (wtDirty.stdout.trim()) return { ok: false, error: 'worktree-has-uncommitted-changes', detail: wtDirty.stdout.trim().split('\n') };
+
+  createCheckpoint(root, 'before-worktree-integrate', { actor: 'ijfw', message: taskId });
+  const merge = git(root, ['merge', '--no-ff', '--no-edit', validation.branch]);
+  if (merge.status !== 0) {
+    updateBlackboardTask(root, taskId, {
+      worktree: { ...wt, status: 'merge-blocked', last_error: merge.stderr || merge.stdout },
+    });
+    appendBlackboardEvent(root, {
+      type: 'worktree.integrate.blocked',
+      actor: 'ijfw',
+      task_id: taskId,
+      artifact_ids: task.task.artifact_ids || [],
+      message: 'Merge blocked; preserve worktree for inspection',
+      data: { stderr: merge.stderr, stdout: merge.stdout },
+    });
+    return { ok: false, error: 'merge-blocked', stderr: merge.stderr, stdout: merge.stdout };
+  }
+
+  const updated = updateBlackboardTask(root, taskId, {
+    worktree: { ...wt, path: validation.path, branch: validation.branch, status: 'integrated', integrated_at: new Date().toISOString() },
+  });
+  appendBlackboardEvent(root, {
+    type: 'worktree.integrated',
+    actor: 'ijfw',
+    task_id: taskId,
+    artifact_ids: task.task.artifact_ids || [],
+    message: validation.path,
+  });
+  if (options.cleanup) cleanupTaskWorktree(root, taskId, { force: true });
+  return { ok: true, task: updated.task };
+}
+
+export function cleanupTaskWorktree(projectRoot, taskId, options = {}) {
+  const root = resolve(projectRoot);
+  const task = findTask(root, taskId);
+  if (!task.ok) return task;
+  const wt = task.task.worktree;
+  if (!wt?.path) return { ok: false, error: 'no-worktree', task: task.task };
+  const validation = validateTaskWorktree(root, wt);
+  if (!validation.ok) return validation;
+  if (wt.status !== 'integrated' && !options.force) {
+    return { ok: false, error: 'worktree-not-cleanup-ready', status: wt.status };
+  }
+
+  const remove = git(root, ['worktree', 'remove', options.force ? '--force' : '', validation.path].filter(Boolean));
+  if (remove.status !== 0 && existsSync(validation.path)) return { ok: false, error: 'worktree-remove-failed', stderr: remove.stderr, stdout: remove.stdout };
+  if (existsSync(validation.path) && options.force) rmSync(validation.path, { recursive: true, force: true });
+  const updated = updateBlackboardTask(root, taskId, {
+    worktree: { ...wt, path: validation.path, branch: validation.branch, status: 'cleaned', cleaned_at: new Date().toISOString() },
+  });
+  appendBlackboardEvent(root, {
+    type: 'worktree.cleaned',
+    actor: 'ijfw',
+    task_id: taskId,
+    artifact_ids: task.task.artifact_ids || [],
+    message: validation.path,
+  });
+  return { ok: true, task: updated.task };
+}
+
+function findTask(projectRoot, taskId) {
+  const tasks = listBlackboardTasks(projectRoot).tasks || [];
+  const task = tasks.find((item) => item.id === taskId);
+  if (!task) return { ok: false, error: 'task-not-found' };
+  return { ok: true, task };
+}
+
+function isGitRepo(projectRoot) {
+  return git(projectRoot, ['rev-parse', '--is-inside-work-tree']).stdout.trim() === 'true';
+}
+
+function isCodeHeavyTask(task) {
+  const text = [
+    ...(task.paths || []),
+    ...(task.artifact_ids || []),
+    task.owner || '',
+    task.title || '',
+  ].join(' ').toLowerCase();
+  return /\.(js|jsx|ts|tsx|py|go|rs|java|kt|rb|php|c|cc|cpp|h|hpp|cs|swift|mjs|cjs)\b/.test(text)
+    || /\b(app|api|module|test|runtime|src|code|software|engineer)\b/.test(text);
+}
+
+function validateTaskWorktree(projectRoot, wt) {
+  const root = resolve(projectRoot);
+  const worktreesRoot = resolve(root, '.ijfw', 'worktrees');
+  const worktreePath = resolve(root, String(wt.path || ''));
+  const pathRel = relative(worktreesRoot, worktreePath);
+  if (!pathRel || pathRel.startsWith('..') || isAbsolute(pathRel)) {
+    return { ok: false, error: 'invalid-worktree-path', path: wt.path };
+  }
+
+  const branch = String(wt.branch || '').trim();
+  if (!branch.startsWith('ijfw/')) {
+    return { ok: false, error: 'invalid-worktree-branch', branch: wt.branch };
+  }
+
+  const listed = git(root, ['worktree', 'list', '--porcelain']);
+  if (listed.status !== 0) {
+    return { ok: true, path: worktreePath, branch, warning: 'worktree-list-unavailable' };
+  }
+  const worktrees = parseWorktreeList(listed.stdout);
+  const canonicalWorktreePath = canonicalPath(worktreePath);
+  const match = worktrees.some((item) => item.path === canonicalWorktreePath && item.branch === branch);
+  if (!match) {
+    return { ok: false, error: 'worktree-metadata-mismatch', path: worktreePath, branch };
+  }
+  return { ok: true, path: worktreePath, branch };
+}
+
+function parseWorktreeList(stdout) {
+  const items = [];
+  let current = null;
+  for (const line of String(stdout || '').split('\n')) {
+    if (line.startsWith('worktree ')) {
+      if (current) items.push(current);
+      current = { path: canonicalPath(line.slice('worktree '.length).trim()), branch: null };
+    } else if (current && line.startsWith('branch ')) {
+      current.branch = line.slice('branch '.length).trim().replace(/^refs\/heads\//, '');
+    } else if (line === '' && current) {
+      items.push(current);
+      current = null;
+    }
+  }
+  if (current) items.push(current);
+  return items;
+}
+
+function canonicalPath(path) {
+  try {
+    return realpathSync.native(path);
+  } catch {
+    return resolve(path);
+  }
+}
+
+function safeTaskId(taskId) {
+  return String(taskId).toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-|-$/g, '') || 'task';
+}
+
+function git(cwd, args) {
+  const res = spawnSync('git', args, { cwd, encoding: 'utf8' });
+  return {
+    status: res.status ?? 1,
+    stdout: res.stdout || '',
+    stderr: res.stderr || (res.error ? res.error.message : ''),
+  };
+}
+
+function dirtyLines(stdout) {
+  return String(stdout || '')
+    .split('\n')
+    .map((line) => line.trimEnd())
+    .filter(Boolean)
+    .filter((line) => {
+      const path = line.slice(3).trim();
+      return !(path === '.ijfw' || path.startsWith('.ijfw/'));
+    });
+}

package/src/team/generator.js

@@ -0,0 +1,119 @@
+// Team Assembly 2.0 generator.
+//
+// Creates project-local agent markdown plus machine-readable charter/workflow
+// contracts from archetype fixtures. This is the first executable slice; later
+// waves can replace fixture selection with richer brief-aware synthesis.
+
+import { existsSync, mkdirSync, readFileSync, readdirSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { writeAtomic } from '../lib/atomic-io.js';
+import { syncCodexAgents } from '../codex-agents.js';
+import { detect } from '../project-type-detector.js';
+import { assertValidTeamBundle, validateTeamCharter, validateWorkflowManifest } from './schemas.js';
+
+const FIXTURE_DIR = resolve(fileURLToPath(new URL('../../fixtures/team/', import.meta.url)));
+const SUPPORTED_ARCHETYPES = new Set(['software', 'design', 'content', 'book', 'research', 'business', 'mixed']);
+
+export function detectTeamArchetype(projectRoot = process.cwd(), options = {}) {
+  if (options.archetype) return normalizeArchetype(options.archetype);
+  const detected = detect(projectRoot, { maxFiles: options.maxFiles || 4000, c9Available: false });
+  return normalizeArchetype(detected.primary_type || detected.type);
+}
+
+export function loadTeamTemplate(archetype) {
+  const normalized = normalizeArchetype(archetype);
+  const path = join(FIXTURE_DIR, `${normalized}.json`);
+  const bundle = JSON.parse(readFileSync(path, 'utf8'));
+  assertValidTeamBundle(bundle);
+  return structuredClone(bundle);
+}
+
+export function createTeamAssembly(projectRoot = process.cwd(), options = {}) {
+  const root = resolve(projectRoot);
+  const archetype = detectTeamArchetype(root, options);
+  const bundle = loadTeamTemplate(archetype);
+  const teamName = options.teamName || `${basename(root) || archetype}-team`;
+
+  bundle.charter.team_name = teamName;
+  bundle.charter.generated_at = new Date().toISOString();
+  bundle.charter.source_archetype = archetype;
+  bundle.workflow.generated_at = bundle.charter.generated_at;
+  bundle.workflow.source_archetype = archetype;
+
+  const teamDir = join(root, '.ijfw', 'team');
+  const agentsDir = join(root, '.ijfw', 'agents');
+  mkdirSync(teamDir, { recursive: true, mode: 0o700 });
+  mkdirSync(agentsDir, { recursive: true, mode: 0o700 });
+
+  const charterPath = join(teamDir, 'charter.json');
+  const workflowPath = join(teamDir, 'workflow.json');
+  if (!options.force && (existsSync(charterPath) || existsSync(workflowPath))) {
+    return { ok: false, error: 'exists', teamDir, agentsDir, archetype };
+  }
+
+  writeAtomic(charterPath, `${JSON.stringify(bundle.charter, null, 2)}\n`, { mode: 0o600 });
+  writeAtomic(workflowPath, `${JSON.stringify(bundle.workflow, null, 2)}\n`, { mode: 0o600 });
+
+  const agentFiles = [];
+  for (const role of bundle.charter.roles) {
+    const agentPath = join(agentsDir, `${role.name}.md`);
+    writeAtomic(agentPath, renderAgent(role, bundle), { mode: 0o600 });
+    agentFiles.push(agentPath);
+  }
+  const codexAgents = syncCodexAgents(root, { bundle });
+
+  return {
+    ok: true,
+    archetype,
+    team_name: teamName,
+    teamDir,
+    agentsDir,
+    charterPath,
+    workflowPath,
+    agentFiles,
+    codexAgents,
+  };
+}
+
+export function readTeamAssembly(projectRoot = process.cwd()) {
+  const root = resolve(projectRoot);
+  const charterPath = join(root, '.ijfw', 'team', 'charter.json');
+  const workflowPath = join(root, '.ijfw', 'team', 'workflow.json');
+  const agentsDir = join(root, '.ijfw', 'agents');
+  const charter = existsSync(charterPath) ? JSON.parse(readFileSync(charterPath, 'utf8')) : null;
+  const workflow = existsSync(workflowPath) ? JSON.parse(readFileSync(workflowPath, 'utf8')) : null;
+  const agents = existsSync(agentsDir)
+    ? readdirSync(agentsDir).filter((file) => file.endsWith('.md')).sort()
+    : [];
+  const charterValidation = charter ? validateTeamCharter(charter) : { ok: false, errors: ['missing charter'] };
+  const workflowValidation = workflow ? validateWorkflowManifest(workflow, charter) : { ok: false, errors: ['missing workflow'] };
+  return {
+    ok: Boolean(charter && workflow && charterValidation.ok && workflowValidation.ok),
+    charterPath,
+    workflowPath,
+    agentsDir,
+    agents,
+    charter,
+    workflow,
+    validation: {
+      charter: charterValidation,
+      workflow: workflowValidation,
+    },
+  };
+}
+
+function normalizeArchetype(value) {
+  const archetype = String(value || '').toLowerCase();
+  return SUPPORTED_ARCHETYPES.has(archetype) ? archetype : 'mixed';
+}
+
+function renderAgent(role, bundle) {
+  const owned = role.owns.map((item) => `- ${item.artifact_type}: ${(item.paths || item.refs || []).join(', ')}`).join('\n');
+  const reviews = role.reviews.map((item) => `- ${item.artifact_type}: ${item.criteria.join(', ')}`).join('\n') || '- None';
+  const phases = role.phase_scope.join(', ');
+  const sections = role.handoff.required_sections.join(', ');
+  const archetypes = bundle.charter.project_archetypes.join(', ');
+
+  return `---\nname: ${role.name}\nmodel: ${role.model}\neffort: ${role.effort || 'medium'}\ndescription: ${role.name} for ${archetypes} projects; owns ${role.owns.map((item) => item.artifact_type).join(', ')}.\nallowed-tools: Read, Write, Edit, Bash\n---\n\n# ${role.name}\n\nYou are part of this project's IJFW team assembly.\n\nProject archetypes: ${archetypes}\nRole type: ${role.role_type}\nPhase scope: ${phases}\n\n## Owns\n\n${owned}\n\n## Reviews\n\n${reviews}\n\n## Coordination\n\n- Claim required: ${role.coordination.claim_required ? 'yes' : 'no'}\n- Parallel safe: ${role.coordination.parallel_safe ? 'yes' : 'no'}\n- Conflicts with: ${role.coordination.conflicts_with.length ? role.coordination.conflicts_with.join(', ') : 'none'}\n\n## Handoff\n\nFormat: ${role.handoff.format}\nRequired sections: ${sections}\n\nRecord claims, findings, blockers, and decisions in .ijfw/blackboard/ when swarm execution is active.\n`;
+}