@liriraid/agentflow-ai 1.0.10

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@liriraid/agentflow-ai",
+  "version": "1.0.10",
+  "description": "Multi-agent workspace orchestrator with TUI. Coordinates AI coding agents over your real frontend and backend projects.",
+  "author": "LiriRaid",
+  "homepage": "https://github.com/LiriRaid/agentflow-ai#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LiriRaid/agentflow-ai.git"
+  },
+  "bugs": {
+    "url": "https://github.com/LiriRaid/agentflow-ai/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "orchestrator.js",
+  "bin": {
+    "agentflow": "bin/agentflow.mjs"
+  },
+  "files": [
+    "bin",
+    "src",
+    "templates",
+    "scripts",
+    "orchestrator.js",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node orchestrator.js",
+    "start:paused": "node orchestrator.js --paused",
+    "start:ink": "node src/ink/index.mjs",
+    "start:ink:paused": "node src/ink/index.mjs --paused",
+    "skills:registry": "node scripts/update-skill-registry.mjs",
+    "openspec:new": "node scripts/scaffold-openspec-change.mjs",
+    "agent-config:init": "node scripts/scaffold-agent-configs.mjs",
+    "cli:help": "node bin/agentflow.mjs --help"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "orchestrator",
+    "agentflow-ai",
+    "claude",
+    "codex",
+    "gemini",
+    "cursor",
+    "opencode",
+    "abacus",
+    "tui",
+    "multi-agent",
+    "coding-assistant",
+    "openspec",
+    "engram",
+    "skills",
+    "agent-config"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "blessed": "^0.1.81",
+    "ink": "^5.2.1",
+    "react": "^18.3.1"
+  }
+}

package/scripts/scaffold-agent-configs.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+
+const ROOT = process.cwd();
+const CONFIG_FILE = path.join(ROOT, 'orchestrator.config.json');
+const CONFIG = fs.existsSync(CONFIG_FILE)
+	? JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'))
+	: {};
+const LANGUAGE = CONFIG.workspaceLanguage === 'en' ? 'en' : 'es';
+
+const CONTENT = {
+	es: {
+		claude: [
+			'# Claude Local Config',
+			'',
+			'Esta carpeta contiene la configuración local del proyecto para Claude.',
+			'',
+			'- `skills/` guarda skills propias del repo',
+			'- `CLAUDE.md` en la raíz define el routing del proyecto',
+			'- esta capa local debe priorizarse sobre configuración global del usuario'
+		],
+		codex: [
+			'# Codex Local Config',
+			'',
+			'Esta carpeta reserva la configuración local del proyecto para Codex.',
+			'',
+			'- hoy se usa como base reusable del proyecto',
+			'- mañana puede alojar prompts, perfiles, reglas o plugins locales',
+			'- no debe depender solo de configuración global del usuario'
+		],
+		opencode: [
+			'# OpenCode Local Config',
+			'',
+			'Esta carpeta reserva la configuración local del proyecto para OpenCode.',
+			'',
+			'- hoy se usa como base reusable del proyecto',
+			'- mañana puede alojar reglas, prompts o convenciones específicas',
+			'- no debe depender solo de configuración global del usuario'
+		],
+		done: 'Configuración local por agente creada o verificada.'
+	},
+	en: {
+		claude: [
+			'# Claude Local Config',
+			'',
+			'This folder contains project-local Claude configuration.',
+			'',
+			'- `skills/` stores repo-specific skills',
+			'- root `CLAUDE.md` defines project routing',
+			'- this local layer should take priority over global user config'
+		],
+		codex: [
+			'# Codex Local Config',
+			'',
+			'This folder reserves project-local configuration for Codex.',
+			'',
+			'- today it is used as the reusable local project base',
+			'- later it can hold prompts, profiles, rules, or local plugins',
+			'- it should not depend only on global user config'
+		],
+		opencode: [
+			'# OpenCode Local Config',
+			'',
+			'This folder reserves project-local configuration for OpenCode.',
+			'',
+			'- today it is used as the reusable local project base',
+			'- later it can hold rules, prompts, or specific conventions',
+			'- it should not depend only on global user config'
+		],
+		done: 'Local agent configuration created or verified.'
+	}
+};
+const L = CONTENT[LANGUAGE];
+
+const files = [
+	[
+		'.claude/README.md',
+		L.claude.join('\n')
+	],
+	[
+		'.codex/README.md',
+		L.codex.join('\n')
+	],
+	[
+		'.opencode/README.md',
+		L.opencode.join('\n')
+	]
+];
+
+for (const [relativePath, content] of files) {
+	const absolutePath = path.join(ROOT, relativePath);
+	fs.mkdirSync(path.dirname(absolutePath), {recursive: true});
+	if (!fs.existsSync(absolutePath)) {
+		fs.writeFileSync(absolutePath, `${content}\n`, 'utf8');
+	}
+}
+
+console.log(L.done);

package/scripts/scaffold-openspec-change.mjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+
+const ROOT = process.cwd();
+const CHANGE_NAME = process.argv[2];
+const CONFIG_FILE = path.join(ROOT, 'orchestrator.config.json');
+const CONFIG = fs.existsSync(CONFIG_FILE)
+	? JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'))
+	: {};
+const LANGUAGE = CONFIG.workspaceLanguage === 'en' ? 'en' : 'es';
+const TEXT = {
+	es: {
+		usage: 'Uso: npm run openspec:new -- <change-name>',
+		readmeIntro: 'Este change fue generado desde las plantillas locales de `openspec/`.',
+		created: base => `OpenSpec change creado en ${base}`
+	},
+	en: {
+		usage: 'Usage: npm run openspec:new -- <change-name>',
+		readmeIntro: 'This change was generated from the local `openspec/` templates.',
+		created: base => `OpenSpec change created at ${base}`
+	}
+};
+const L = TEXT[LANGUAGE];
+
+if (!CHANGE_NAME) {
+	console.error(L.usage);
+	process.exit(1);
+}
+
+const base = path.join(ROOT, 'openspec', 'changes', CHANGE_NAME);
+const templates = path.join(ROOT, 'openspec', 'templates');
+
+const files = [
+	['proposal.md', 'proposal.md'],
+	['design.md', 'design.md'],
+	['tasks.md', 'tasks.md'],
+	['verify-report.md', 'verify-report.md'],
+	['archive-report.md', 'archive-report.md'],
+	['.openspec.yaml', 'change-metadata.yaml']
+];
+
+fs.mkdirSync(base, {recursive: true});
+const specsDir = path.join(base, 'specs');
+fs.mkdirSync(specsDir, {recursive: true});
+
+for (const [targetName, templateName] of files) {
+	const target = path.join(base, targetName);
+	if (fs.existsSync(target)) continue;
+	const template = fs.readFileSync(path.join(templates, templateName), 'utf8');
+	const content = template.replaceAll('<change-name>', CHANGE_NAME);
+	fs.writeFileSync(target, content.endsWith('\n') ? content : `${content}\n`, 'utf8');
+}
+
+const specTemplate = fs.readFileSync(path.join(templates, 'spec.md'), 'utf8');
+const specTarget = path.join(specsDir, 'spec.md');
+if (!fs.existsSync(specTarget)) {
+	const specContent = specTemplate.replaceAll('<change-name>', CHANGE_NAME);
+	fs.writeFileSync(specTarget, specContent.endsWith('\n') ? specContent : `${specContent}\n`, 'utf8');
+}
+
+const readme = [
+	`# ${CHANGE_NAME}`,
+	'',
+	L.readmeIntro,
+	'',
+	'## Files',
+	'',
+	'- `proposal.md`',
+	'- `design.md`',
+	'- `tasks.md`',
+	'- `verify-report.md`',
+	'- `archive-report.md`',
+	'- `.openspec.yaml`',
+	'- `specs/spec.md`'
+].join('\n');
+
+const changeReadme = path.join(base, 'README.md');
+if (!fs.existsSync(changeReadme)) {
+	fs.writeFileSync(changeReadme, `${readme}\n`, 'utf8');
+}
+
+console.log(L.created(base));

package/scripts/update-skill-registry.mjs

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+
+const ROOT = process.cwd();
+const SKILLS_DIR = path.join(ROOT, '.claude', 'skills');
+const OUTPUT_DIR = path.join(ROOT, '.atl');
+const OUTPUT_FILE = path.join(OUTPUT_DIR, 'skill-registry.md');
+const CONFIG_FILE = path.join(ROOT, 'orchestrator.config.json');
+const CONFIG = fs.existsSync(CONFIG_FILE)
+	? JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'))
+	: {};
+const LANGUAGE = CONFIG.workspaceLanguage === 'en' ? 'en' : 'es';
+const TEXT = {
+	es: {
+		fallbackRule: 'Usa esta skill solo para el propósito definido en su descripción.',
+		entryPoint: 'Punto de entrada de la sesión del orquestador',
+		intro:
+			'**Project-local only.** Este registry prioriza las skills dentro de `./.claude/skills/` para evitar depender de instalaciones globales como `gentle-ai`.',
+		noSkills: '| manual | none | _No hay skills locales todavía_ |',
+		noRegistered: 'No hay skills locales registradas todavía.',
+		noConventions: '| none | none | No se encontraron archivos de convención |',
+		policy: [
+			'Prioriza siempre skills locales de `./.claude/skills/`.',
+			'No dependas de `~/.claude/skills/` para el funcionamiento principal del orquestador.',
+			'Si una skill global existe con el mismo nombre, la local del proyecto gana.',
+			'Regenera este archivo después de crear, borrar o cambiar skills locales.'
+		],
+		updated: file => `Skill registry actualizado en ${file}`
+	},
+	en: {
+		fallbackRule: 'Use this skill only for the purpose defined in its description.',
+		entryPoint: 'Orchestrator session entry point',
+		intro:
+			'**Project-local only.** This registry prioritizes skills inside `./.claude/skills/` so the workflow does not depend on global installations such as `gentle-ai`.',
+		noSkills: '| manual | none | _No local skills yet_ |',
+		noRegistered: 'No local skills are registered yet.',
+		noConventions: '| none | none | No convention files found |',
+		policy: [
+			'Always prefer local skills from `./.claude/skills/`.',
+			'Do not depend on `~/.claude/skills/` for the main orchestrator workflow.',
+			'If a global skill has the same name as a project-local skill, the local skill wins.',
+			'Regenerate this file after creating, deleting, or changing local skills.'
+		],
+		updated: file => `Skill registry updated at ${file}`
+	}
+};
+const L = TEXT[LANGUAGE];
+
+const CONVENTION_FILES = [
+	'AGENTS.md',
+	'agents.md',
+	'CLAUDE.md',
+	'ORCHESTRATOR.md',
+	'PROJECT.md',
+	'README.md'
+];
+
+function ensureDir(dir) {
+	fs.mkdirSync(dir, {recursive: true});
+}
+
+function listSkillFiles(dir) {
+	if (!fs.existsSync(dir)) return [];
+	const entries = fs.readdirSync(dir, {withFileTypes: true});
+	const files = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const name = entry.name;
+		if (name === '_shared') continue;
+		const file = path.join(dir, name, 'SKILL.md');
+		if (fs.existsSync(file)) files.push(file);
+	}
+	return files.sort((a, b) => a.localeCompare(b));
+}
+
+function extractName(content, fallback) {
+	const match = content.match(/^\s*name:\s*(.+)$/im);
+	return match ? match[1].trim().replace(/^['"]|['"]$/g, '') : fallback;
+}
+
+function extractTrigger(content = '') {
+	const triggerLine = content.match(/^Trigger:\s*(.+)$/im);
+	if (triggerLine) return triggerLine[1].trim();
+	const descriptionTrigger = content.match(/Trigger:\s*([^.\n]+)/im);
+	return descriptionTrigger ? descriptionTrigger[1].trim() : 'manual';
+}
+
+function compactRules(content) {
+	const lines = content
+		.split('\n')
+		.map(line => line.trim())
+		.filter(Boolean);
+
+	const bullets = [];
+	for (const line of lines) {
+		if (line.startsWith('- ') || line.startsWith('* ')) {
+			bullets.push(line.replace(/^[-*]\s*/, ''));
+		}
+	}
+
+	const selected = bullets.slice(0, 8);
+	return selected.length > 0
+		? selected
+		: [L.fallbackRule];
+}
+
+function toPosix(filePath) {
+	return filePath.replaceAll('\\', '/');
+}
+
+function buildRegistry() {
+	const skillFiles = listSkillFiles(SKILLS_DIR);
+	const skills = skillFiles.map(file => {
+		const content = fs.readFileSync(file, 'utf8');
+		return {
+			name: extractName(content, path.basename(path.dirname(file))),
+			trigger: extractTrigger(content),
+			path: toPosix(path.relative(ROOT, file)),
+			rules: compactRules(content)
+		};
+	});
+
+	const conventions = CONVENTION_FILES.filter(file => fs.existsSync(path.join(ROOT, file))).map(
+		file => ({
+			file,
+			path: toPosix(file),
+			notes: file === 'ORCHESTRATOR.md' ? L.entryPoint : ''
+		})
+	);
+
+	const registry = [
+		'# Skill Registry',
+		'',
+		L.intro,
+		'',
+		'## User Skills',
+		'',
+		'| Trigger | Skill | Path |',
+		'|---------|-------|------|',
+		...(skills.length > 0
+			? skills.map(skill => `| ${skill.trigger.replaceAll('|', '\\|')} | ${skill.name} | \`${skill.path}\` |`)
+			: [L.noSkills]),
+		'',
+		'## Compact Rules',
+		'',
+		...(skills.length > 0
+			? skills.flatMap(skill => [
+					`### ${skill.name}`,
+					...skill.rules.map(rule => `- ${rule}`),
+					''
+			  ])
+			: [L.noRegistered, '']),
+		'## Project Conventions',
+		'',
+		'| File | Path | Notes |',
+		'|------|------|-------|',
+		...(conventions.length > 0
+			? conventions.map(item => `| ${item.file} | \`${item.path}\` | ${item.notes || ''} |`)
+			: [L.noConventions]),
+		'',
+		'## Resolution Policy',
+		'',
+		...L.policy.map(rule => `- ${rule}`)
+	];
+
+	return registry.join('\n');
+}
+
+ensureDir(OUTPUT_DIR);
+const registry = buildRegistry();
+fs.writeFileSync(OUTPUT_FILE, `${registry}\n`, 'utf8');
+console.log(L.updated(OUTPUT_FILE));

package/src/ink/app.mjs

@@ -0,0 +1,240 @@
+import React, {useMemo} from 'react';
+import {Box, Text, useInput, useStdout} from 'ink';
+
+const h = React.createElement;
+
+const COLORS = {
+	accent: 'cyan',
+	success: 'green',
+	warning: 'yellow',
+	muted: 'gray'
+};
+
+const truncate = (value, size) => {
+	if (!value) return '';
+	return value.length > size ? `${value.slice(0, Math.max(0, size - 1))}…` : value;
+};
+
+const TEXT = {
+	es: {
+		busy: 'Ocupado',
+		idle: 'En espera',
+		noTask: 'Sin tarea activa',
+		ready: 'Listo para trabajar',
+		project: 'Proyecto',
+		state: 'Estado',
+		active: 'Activo',
+		busyCount: 'Activos',
+		pending: 'Pendientes',
+		completed: 'Completadas',
+		cost: 'Costo',
+		paused: 'Pausado',
+		preview: 'Explorando Ink',
+		shortcuts: 'Atajos',
+		start: 'iniciar/reanudar',
+		pause: 'pausar',
+		reload: 'recargar QUEUE.md',
+		quit: 'salir y matar agentes',
+		summary: 'Resumen',
+		activeQueue: 'Cola activa',
+		emptyQueue: 'No hay tareas pendientes.',
+		log: 'Registro'
+	},
+	en: {
+		busy: 'Busy',
+		idle: 'Idle',
+		noTask: 'No active task',
+		ready: 'Ready to work',
+		project: 'Project',
+		state: 'State',
+		active: 'Active',
+		busyCount: 'Busy',
+		pending: 'Pending',
+		completed: 'Completed',
+		cost: 'Cost',
+		paused: 'Paused',
+		preview: 'Exploring Ink',
+		shortcuts: 'Shortcuts',
+		start: 'start/resume',
+		pause: 'pause',
+		reload: 'reload QUEUE.md',
+		quit: 'quit and stop agents',
+		summary: 'Summary',
+		activeQueue: 'Active Queue',
+		emptyQueue: 'No pending tasks.',
+		log: 'Log'
+	}
+};
+
+const Panel = ({title, width, children}) =>
+	h(
+		Box,
+		{
+			borderStyle: 'round',
+			borderColor: COLORS.accent,
+			paddingX: 1,
+			paddingY: 0,
+			width,
+			flexDirection: 'column'
+		},
+		h(Text, {bold: true, color: COLORS.accent}, title),
+		h(Box, {marginTop: 0, flexDirection: 'column'}, children)
+	);
+
+const AgentCard = ({agent, text}) => {
+	const statusColor = agent.status === 'busy' ? COLORS.success : COLORS.muted;
+	return h(
+		Box,
+		{
+			borderStyle: 'round',
+			borderColor: statusColor,
+			width: '24%',
+			minHeight: 6,
+			paddingX: 1,
+			flexDirection: 'column'
+		},
+		h(Text, {bold: true}, agent.name),
+		h(Text, {color: statusColor}, agent.status === 'busy' ? text.busy : text.idle),
+		h(
+			Text,
+			{color: COLORS.muted},
+			agent.task ? truncate(agent.task, 26) : text.noTask
+		),
+		h(Text, {color: COLORS.muted}, agent.detail || text.ready)
+	);
+};
+
+export function App({snapshot, paused = false, onAction}) {
+	const {stdout} = useStdout();
+	const columns = stdout?.columns ?? 120;
+	const isCompact = columns < 120;
+	const summaryWidth = Math.max(20, Math.floor((isCompact ? columns : columns * 0.28) - 8));
+	const queueWidth = Math.max(20, Math.floor((isCompact ? columns : columns * 0.42) - 8));
+	const logWidth = Math.max(20, Math.floor((isCompact ? columns : columns * 0.35) - 8));
+	const heroWidth = Math.max(20, columns - 8);
+	const shortcutWidth = Math.max(20, columns - 4);
+	const agentWidth = Math.max(18, Math.floor((isCompact ? columns : columns * 0.24) - 8));
+	const text = TEXT[snapshot.workspaceLanguage === 'en' ? 'en' : 'es'];
+
+	useInput((input, key) => {
+		if (key.ctrl && input === 'c') {
+			onAction?.('quit');
+			return;
+		}
+
+		const normalized = input.toLowerCase();
+		if (normalized === 'r') onAction?.('reload');
+		if (normalized === 's') onAction?.('start');
+		if (normalized === 'p') onAction?.('pause');
+		if (normalized === 'q') onAction?.('quit');
+	});
+
+	const liveActiveLabel = snapshot.activeLabel || '0s';
+
+	const busyCount = snapshot.agents.filter(agent => agent.status === 'busy').length;
+	const overview = useMemo(
+		() => [
+			`${text.project}: ${snapshot.projectName}`,
+			`${text.state}: ${snapshot.stateLabel || (paused ? text.paused : text.preview)}`,
+			`${text.active}: ${liveActiveLabel}`,
+			`${text.busyCount}: ${busyCount}/${snapshot.agents.length}`,
+			`${text.pending}: ${snapshot.queue.length}`,
+			`${text.completed}: ${snapshot.completed.length}`,
+			`${text.cost}: ${snapshot.totalCost}`
+		],
+		[busyCount, liveActiveLabel, paused, snapshot, text]
+	);
+	const heroLine = truncate(
+		`${snapshot.timestamp}  |  ${snapshot.stateLabel || (paused ? text.paused : text.preview)}  |  ${text.active.toLowerCase()} ${liveActiveLabel}`,
+		heroWidth
+	);
+	const shortcutRest = truncate(
+		`S ${text.start}  P ${text.pause}  R ${text.reload}  Q ${text.quit}`,
+		Math.max(0, shortcutWidth - 8)
+	);
+
+	return h(
+		Box,
+		{flexDirection: 'column', paddingX: 1, paddingY: 0},
+		h(
+			Box,
+			{
+				borderStyle: 'round',
+				borderColor: COLORS.accent,
+				paddingX: 1,
+				paddingY: 0,
+				marginBottom: 1,
+				flexDirection: 'column'
+			},
+			h(Text, {bold: true, color: COLORS.accent}, snapshot.projectName),
+			h(Text, {color: COLORS.muted}, heroLine)
+		),
+		h(
+			Box,
+			{marginBottom: 1},
+			h(Text, {color: COLORS.warning}, `${text.shortcuts}: `),
+			h(Text, {bold: true}, 'S'),
+			h(Text, {color: COLORS.muted}, truncate(` ${text.start}  `, Math.max(0, shortcutWidth - 40))),
+			h(Text, {bold: true}, 'P'),
+			h(Text, {color: COLORS.muted}, truncate(` ${text.pause}  `, Math.max(0, shortcutWidth - 55))),
+			h(Text, {bold: true}, 'R'),
+			h(Text, {color: COLORS.muted}, truncate(` ${text.reload}  `, Math.max(0, shortcutWidth - 70))),
+			h(Text, {bold: true}, 'Q'),
+			h(Text, {color: COLORS.muted}, truncate(` ${text.quit}`, Math.max(0, shortcutWidth - 90)))
+		),
+		h(
+			Box,
+			{
+				flexDirection: isCompact ? 'column' : 'row',
+				gap: 1,
+				marginBottom: 1
+			},
+			h(
+				Panel,
+				{title: text.summary, width: isCompact ? '100%' : '28%'},
+				...overview.map(line => h(Text, {key: line}, truncate(line, summaryWidth)))
+			),
+			h(
+				Panel,
+				{title: text.activeQueue, width: isCompact ? '100%' : '42%'},
+				...(snapshot.queue.length === 0
+					? [h(Text, {color: COLORS.muted, key: 'empty-queue'}, text.emptyQueue)]
+					: snapshot.queue.slice(0, 6).map(task =>
+							h(
+								Text,
+								{key: task.id},
+								truncate(`${task.id} · ${task.title}`, queueWidth)
+							)
+					  ))
+			),
+			h(
+				Panel,
+				{title: text.log, width: isCompact ? '100%' : '35%'},
+				...snapshot.logs
+					.slice(-6)
+					.map(entry => h(Text, {key: entry, color: COLORS.muted}, truncate(entry, logWidth)))
+			)
+		),
+		h(
+			Box,
+			{
+				flexDirection: 'row',
+				flexWrap: 'wrap',
+				columnGap: 1,
+				rowGap: 1
+			},
+			...snapshot.agents.map(agent =>
+				h(AgentCard, {
+					text,
+					key: agent.name,
+					agent: {
+						...agent,
+						name: truncate(agent.name, agentWidth),
+						task: agent.task ? truncate(agent.task, agentWidth) : null,
+						detail: truncate(agent.detail || text.ready, agentWidth)
+					}
+				})
+			)
+		)
+	);
+}