ac-framework 1.9.3 → 1.9.4

package/src/agents/role-prompts.js

@@ -0,0 +1,48 @@
+export const ROLE_SYSTEM_PROMPTS = {
+  planner: [
+    'You are the Planner in a collaborative engineering team.',
+    'Your goal is to propose clear implementation strategy, scope, and sequencing.',
+    'You must produce concrete, actionable guidance, not generic ideas.',
+    'When responding, always consider user task and all prior teammate messages.',
+  ].join(' '),
+  critic: [
+    'You are the Critic in a collaborative engineering team.',
+    'You must identify at least two concrete risks, blind spots, or failure modes.',
+    'Do not approve a plan without specific scrutiny.',
+    'Propose mitigations with practical tradeoffs.',
+  ].join(' '),
+  coder: [
+    'You are the Coder in a collaborative engineering team.',
+    'Translate accepted plan and critique into implementation-level steps.',
+    'Focus on APIs, file structure, edge cases, and validation strategy.',
+    'Keep recommendations production-oriented and test-aware.',
+  ].join(' '),
+  reviewer: [
+    'You are the Reviewer in a collaborative engineering team.',
+    'Synthesize proposals, call out unresolved conflicts, and decide readiness.',
+    'If unresolved issues remain, request another round and list blockers.',
+    'If convergence is reached, produce a concise final plan.',
+  ].join(' '),
+};
+
+export function buildAgentPrompt({ role, task, round, messages, maxMessages = 24 }) {
+  const recent = messages.slice(-maxMessages);
+  const transcript = recent.length
+    ? recent.map((msg, idx) => `${idx + 1}. [${msg.from}] ${msg.content}`).join('\n')
+    : 'No previous messages.';
+
+  return [
+    `ROLE: ${role}`,
+    `ROUND: ${round}`,
+    '',
+    `TASK: ${task}`,
+    '',
+    'TEAM TRANSCRIPT (latest first-order history):',
+    transcript,
+    '',
+    'Respond with this structure:',
+    '1) Analysis (short)',
+    '2) Contribution (what you add)',
+    '3) Open Issues (numbered, can be empty)',
+  ].join('\n');
+}

package/src/agents/scheduler.js

@@ -0,0 +1,22 @@
+export function nextRole(state) {
+  const roles = state.roles || [];
+  if (roles.length === 0) {
+    throw new Error('No roles configured for collaborative session');
+  }
+
+  const index = state.nextRoleIndex ?? 0;
+  const role = roles[index % roles.length];
+  const nextRoleIndex = (index + 1) % roles.length;
+  const round = nextRoleIndex === 0 ? state.round + 1 : state.round;
+
+  return {
+    role,
+    nextRoleIndex,
+    round,
+  };
+}
+
+export function shouldStop(state) {
+  if (state.status && state.status !== 'running') return true;
+  return state.round > state.maxRounds;
+}

package/src/agents/state-store.js

@@ -0,0 +1,240 @@
+import { appendFile, mkdir, open, readFile, readdir, stat, unlink, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import {
+  COLLAB_ROLES,
+  DEFAULT_MAX_ROUNDS,
+  SESSION_ROOT_DIR,
+  CURRENT_SESSION_FILE,
+} from './constants.js';
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function ensureSessionRoot() {
+  await mkdir(SESSION_ROOT_DIR, { recursive: true });
+}
+
+async function writeCurrentSession(sessionId, updatedAt = new Date().toISOString()) {
+  await writeFile(CURRENT_SESSION_FILE, JSON.stringify({ sessionId, updatedAt }, null, 2) + '\n', 'utf8');
+}
+
+export function getSessionDir(sessionId) {
+  return join(SESSION_ROOT_DIR, sessionId);
+}
+
+function getSessionLockPath(sessionId) {
+  return join(getSessionDir(sessionId), '.session.lock');
+}
+
+function getSessionStatePath(sessionId) {
+  return join(getSessionDir(sessionId), 'state.json');
+}
+
+function getTranscriptPath(sessionId) {
+  return join(getSessionDir(sessionId), 'transcript.jsonl');
+}
+
+function initialState(task, options = {}) {
+  const sessionId = randomUUID();
+  const createdAt = new Date().toISOString();
+  return {
+    sessionId,
+    createdAt,
+    updatedAt: createdAt,
+    status: 'running',
+    task,
+    round: 1,
+    maxRounds: Number.isInteger(options.maxRounds) ? options.maxRounds : DEFAULT_MAX_ROUNDS,
+    activeAgent: null,
+    nextRoleIndex: 0,
+    roles: options.roles?.length ? options.roles : COLLAB_ROLES,
+    workingDirectory: options.workingDirectory || process.cwd(),
+    model: options.model || null,
+    tmuxSessionName: options.tmuxSessionName || null,
+    messages: [
+      {
+        from: 'user',
+        role: 'user',
+        timestamp: createdAt,
+        content: task,
+      },
+    ],
+    decisions: [],
+    conflicts: [],
+  };
+}
+
+export async function createSession(task, options = {}) {
+  await ensureSessionRoot();
+  const state = initialState(task, options);
+  const sessionDir = getSessionDir(state.sessionId);
+  await mkdir(sessionDir, { recursive: true });
+  await writeFile(getSessionStatePath(state.sessionId), JSON.stringify(state, null, 2) + '\n', 'utf8');
+  await writeCurrentSession(state.sessionId, state.updatedAt);
+  await appendTranscript(state.sessionId, state.messages[0]);
+  return state;
+}
+
+export async function appendTranscript(sessionId, message) {
+  const transcriptPath = getTranscriptPath(sessionId);
+  const line = JSON.stringify(message) + '\n';
+  if (!existsSync(transcriptPath)) {
+    await writeFile(transcriptPath, line, 'utf8');
+    return;
+  }
+  await appendFile(transcriptPath, line, 'utf8');
+}
+
+export async function loadCurrentSessionId() {
+  if (!existsSync(CURRENT_SESSION_FILE)) return null;
+  const raw = await readFile(CURRENT_SESSION_FILE, 'utf8');
+  const parsed = JSON.parse(raw);
+  return parsed?.sessionId || null;
+}
+
+export async function loadSessionState(sessionId) {
+  const raw = await readFile(getSessionStatePath(sessionId), 'utf8');
+  return JSON.parse(raw);
+}
+
+export async function saveSessionState(state) {
+  const updated = {
+    ...state,
+    updatedAt: new Date().toISOString(),
+  };
+  await writeFile(getSessionStatePath(updated.sessionId), JSON.stringify(updated, null, 2) + '\n', 'utf8');
+  await writeCurrentSession(updated.sessionId, updated.updatedAt);
+  return updated;
+}
+
+export async function setCurrentSession(sessionId) {
+  await ensureSessionRoot();
+  await writeCurrentSession(sessionId, new Date().toISOString());
+}
+
+export async function listSessions(limit = 20) {
+  await ensureSessionRoot();
+  const entries = await readdir(SESSION_ROOT_DIR, { withFileTypes: true });
+  const dirs = entries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name);
+
+  const sessions = [];
+  for (const dirName of dirs) {
+    const sessionId = dirName;
+    const statePath = getSessionStatePath(sessionId);
+    if (!existsSync(statePath)) continue;
+    try {
+      const state = await loadSessionState(sessionId);
+      const stateStats = await stat(statePath);
+      sessions.push({
+        sessionId: state.sessionId,
+        status: state.status,
+        task: state.task,
+        round: state.round,
+        maxRounds: state.maxRounds,
+        tmuxSessionName: state.tmuxSessionName || null,
+        createdAt: state.createdAt,
+        updatedAt: state.updatedAt,
+        mtime: stateStats.mtimeMs,
+      });
+    } catch {
+      // ignore corrupted session entries and continue
+    }
+  }
+
+  sessions.sort((a, b) => b.mtime - a.mtime);
+  return sessions.slice(0, Math.max(1, limit));
+}
+
+export async function loadTranscript(sessionId) {
+  const transcriptPath = getTranscriptPath(sessionId);
+  if (!existsSync(transcriptPath)) return [];
+  const raw = await readFile(transcriptPath, 'utf8');
+  return raw
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+export async function addAgentMessage(state, role, content) {
+  const msg = {
+    from: role,
+    role,
+    timestamp: new Date().toISOString(),
+    content,
+  };
+  const updated = {
+    ...state,
+    messages: [...state.messages, msg],
+  };
+  await appendTranscript(state.sessionId, msg);
+  return updated;
+}
+
+export async function addUserMessage(state, content) {
+  const msg = {
+    from: 'user',
+    role: 'user',
+    timestamp: new Date().toISOString(),
+    content,
+  };
+  const updated = {
+    ...state,
+    messages: [...state.messages, msg],
+  };
+  await appendTranscript(state.sessionId, msg);
+  return updated;
+}
+
+export async function stopSession(state, reason = 'stopped') {
+  const updated = {
+    ...state,
+    status: reason,
+    activeAgent: null,
+  };
+  return saveSessionState(updated);
+}
+
+export async function withSessionLock(sessionId, fn, options = {}) {
+  const timeoutMs = Number.isInteger(options.timeoutMs) ? options.timeoutMs : 900000;
+  const retryMs = Number.isInteger(options.retryMs) ? options.retryMs : 100;
+  const lockPath = getSessionLockPath(sessionId);
+
+  let handle = null;
+  const started = Date.now();
+  while (!handle) {
+    try {
+      handle = await open(lockPath, 'wx');
+    } catch (error) {
+      if (error.code !== 'EEXIST') {
+        throw error;
+      }
+      if (Date.now() - started >= timeoutMs) {
+        throw new Error(`Timed out waiting session lock for ${sessionId}`);
+      }
+      await sleep(retryMs);
+    }
+  }
+
+  try {
+    return await fn();
+  } finally {
+    try {
+      await handle.close();
+    } finally {
+      await unlink(lockPath).catch(() => {});
+    }
+  }
+}

package/src/cli.js

@@ -8,6 +8,7 @@ import { initCommand } from './commands/init.js';
 import { updateCommand } from './commands/update.js';
 import { specCommand } from './commands/spec.js';
 import { memoryCommand } from './commands/memory.js';
+import { agentsCommand } from './commands/agents.js';
 import { showBanner } from './ui/banner.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -40,5 +41,6 @@ program
 
 program.addCommand(specCommand());
 program.addCommand(memoryCommand());
+program.addCommand(agentsCommand());
 
 program.parse();