@liriraid/agentflow-ai 1.0.10

package/src/ink/index.mjs

@@ -0,0 +1,400 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import process from 'process';
+import {spawn} from 'child_process';
+import {fileURLToPath} from 'url';
+import React from 'react';
+import {render} from 'ink';
+import {App} from './app.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const PACKAGE_ROOT = path.resolve(path.dirname(__filename), '..', '..');
+const ROOT = process.cwd();
+const CONFIG_FILE = path.join(ROOT, 'orchestrator.config.json');
+const ENGINE_FILE = path.join(PACKAGE_ROOT, 'orchestrator.js');
+const STATE_FILE = path.join(ROOT, 'logs', 'orchestrator-state.json');
+const LOCK_FILE = path.join(ROOT, 'logs', 'orchestrator.lock');
+const CONTROL_FILE = path.join(ROOT, 'logs', 'orchestrator-control.json');
+
+const argv = process.argv.slice(2);
+const startPaused = argv.includes('--paused');
+const TEXT = {
+	es: {
+		configMissing: root =>
+			`No se encontró orchestrator.config.json en ${root}. Ejecuta esta UI desde la raíz del proyecto.`,
+		waitingEngine: 'Esperando motor',
+		startingEngine: '[INFO] Iniciando motor del orchestrator...',
+		paused: 'Pausado',
+		running: 'Ejecutando',
+		ready: 'Listo para trabajar',
+		attached: pid => `Adjuntado a motor existente (PID ${pid})`,
+		startPaused: 'Levantando motor en modo PAUSADO',
+		startRunning: 'Levantando motor en modo EJECUTANDO',
+		engineExited: code => `Motor finalizado con código ${code ?? 0}`,
+		engineError: message => `Error iniciando motor: ${message}`,
+		resume: 'Comando enviado: REANUDAR',
+		pause: 'Comando enviado: PAUSAR',
+		reload: 'Comando enviado: RECARGAR COLA',
+		quit: 'Comando enviado: SALIR'
+	},
+	en: {
+		configMissing: root =>
+			`orchestrator.config.json was not found in ${root}. Run this UI from the project root.`,
+		waitingEngine: 'Waiting for engine',
+		startingEngine: '[INFO] Starting orchestrator engine...',
+		paused: 'Paused',
+		running: 'Running',
+		ready: 'Ready to work',
+		attached: pid => `Attached to existing engine (PID ${pid})`,
+		startPaused: 'Starting engine in PAUSED mode',
+		startRunning: 'Starting engine in RUNNING mode',
+		engineExited: code => `Engine exited with code ${code ?? 0}`,
+		engineError: message => `Error starting engine: ${message}`,
+		resume: 'Command sent: RESUME',
+		pause: 'Command sent: PAUSE',
+		reload: 'Command sent: RELOAD QUEUE',
+		quit: 'Command sent: QUIT'
+	}
+};
+
+function languageFromConfig(config) {
+	return config.workspaceLanguage === 'en' ? 'en' : 'es';
+}
+
+let detectedLanguage = 'en';
+try {
+	if (fs.existsSync(CONFIG_FILE)) {
+		const _cfg = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+		detectedLanguage = languageFromConfig(_cfg);
+	}
+} catch {}
+
+const SYSTEM_LOCALE = Intl.DateTimeFormat().resolvedOptions().locale;
+function getLocale() { return SYSTEM_LOCALE; }
+
+// Limpiar control.json orphan al iniciar
+if (fs.existsSync(CONTROL_FILE)) {
+	try {
+		const content = JSON.parse(fs.readFileSync(CONTROL_FILE, 'utf8'));
+		const age = Date.now() - (content.requestedAt || 0);
+		if (age > 5000) {
+			fs.unlinkSync(CONTROL_FILE);
+		}
+	} catch {
+		try { fs.unlinkSync(CONTROL_FILE); } catch {}
+	}
+}
+
+let inkApp = null;
+let refreshTimer = null;
+let spawnedEngine = null;
+let localEvents = [];
+let quitRequested = false;
+let resizeTimer = null;
+let isResizing = false;
+let lastColumns = process.stdout?.columns ?? 0;
+
+function normalizeInlineMessage(message) {
+	return String(message ?? '')
+		.replace(/\r?\n+/g, ' ')
+		.replace(/\s{2,}/g, ' ')
+		.trim();
+}
+
+function pushLocalEvent(message) {
+	const normalized = normalizeInlineMessage(message);
+	if (!normalized) return;
+	const line = `[${new Date().toLocaleTimeString(getLocale(), {hour12: false})}] [INK] ${normalized}`;
+	localEvents.push(line);
+	if (localEvents.length > 20) localEvents.shift();
+}
+
+function loadConfig() {
+	if (!fs.existsSync(CONFIG_FILE)) {
+		throw new Error(TEXT[detectedLanguage].configMissing(ROOT));
+	}
+
+	const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+	detectedLanguage = languageFromConfig(config);
+	return config;
+}
+
+function isPidRunning(pid) {
+	if (!pid || Number.isNaN(pid)) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function readLockPid() {
+	if (!fs.existsSync(LOCK_FILE)) return null;
+	const raw = fs.readFileSync(LOCK_FILE, 'utf8').trim();
+	const pid = Number.parseInt(raw, 10);
+	return Number.isNaN(pid) ? null : pid;
+}
+
+function formatDuration(seconds) {
+	if (!Number.isFinite(seconds) || seconds <= 0) return '0s';
+	if (seconds < 60) return `${seconds}s`;
+	const minutes = Math.floor(seconds / 60);
+	if (minutes < 60) return `${minutes}m${seconds % 60 ? `${seconds % 60}s` : ''}`;
+	const hours = Math.floor(minutes / 60);
+	return `${hours}h${minutes % 60}m`;
+}
+
+function readEngineState() {
+	if (!fs.existsSync(STATE_FILE)) return null;
+	try {
+		return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+	} catch {
+		return null;
+	}
+}
+
+function sendControlCommand(type) {
+	fs.mkdirSync(path.dirname(CONTROL_FILE), {recursive: true});
+	fs.writeFileSync(
+		CONTROL_FILE,
+		JSON.stringify(
+			{
+				type,
+				requestedAt: Date.now(),
+				source: 'ink'
+			},
+			null,
+			2
+		) + '\n',
+		'utf8'
+	);
+}
+
+function buildFallbackSnapshot(config) {
+	const language = languageFromConfig(config);
+	const text = TEXT[language];
+	const agents = Object.keys(config.agents || {}).map(name => ({
+		name,
+		status: 'idle',
+		task: null,
+		detail: text.waitingEngine
+	}));
+
+	return {
+		projectName: config.projectName || 'Orchestrator Multi-Agents',
+		timestamp: new Date().toLocaleString(getLocale(), {hour12: false}),
+		totalCost: '$0.00',
+		queue: [],
+		completed: [],
+		logs:
+			localEvents.length > 0
+				? localEvents.slice(-6)
+				: [text.startingEngine],
+		agents,
+		stateLabel: startPaused ? text.paused : text.running,
+		workspaceLanguage: language,
+		activeLabel: '0s',
+		startedAt: null,
+		isRunning: false
+	};
+}
+
+function buildSnapshot() {
+	const config = loadConfig();
+	const language = languageFromConfig(config);
+	const text = TEXT[language];
+	const engineState = readEngineState();
+
+	if (!engineState) {
+		return buildFallbackSnapshot(config);
+	}
+
+	const busyCount = Object.values(engineState.agents || {}).filter(
+		agent => agent.status === 'busy'
+	).length;
+
+	const agents = Object.entries(config.agents || {}).map(([name]) => {
+		const agent = engineState.agents?.[name];
+		return {
+			name,
+			status: agent?.status === 'busy' ? 'busy' : 'idle',
+			task: agent?.task ? `${agent.task.id} · ${agent.task.title}` : null,
+			detail:
+				agent?.status === 'busy'
+					? `${agent.task?.priority || 'P?'} · ${agent.task?.repo || 'repo'}`
+					: agent?.lastLine || text.ready
+		};
+	});
+
+	const activeSeconds = engineState.startTime
+		? Math.max(0, Math.round((Date.now() - engineState.startTime) / 1000))
+		: 0;
+
+	return {
+		projectName: engineState.projectName || config.projectName || 'Orchestrator Multi-Agents',
+		timestamp: new Date().toLocaleString(getLocale(), {hour12: false}),
+		totalCost:
+			typeof engineState.totalCost === 'number'
+				? `$${engineState.totalCost.toFixed(2)}`
+				: '$0.00',
+		queue: engineState.queue || [],
+		completed: engineState.completed || [],
+		logs:
+			engineState.logs && engineState.logs.length > 0
+				? engineState.logs.slice(-6)
+				: localEvents.slice(-6),
+		agents,
+		stateLabel: engineState.paused ? text.paused : text.running,
+		workspaceLanguage: engineState.workspaceLanguage || language,
+		activeLabel: formatDuration(activeSeconds),
+		startedAt: engineState.startTime || null,
+		isRunning: busyCount > 0 || isPidRunning(engineState.pid)
+	};
+}
+
+function ensureEngine() {
+	const config = loadConfig();
+	const text = TEXT[languageFromConfig(config)];
+	const runningPid = readLockPid();
+	if (runningPid && isPidRunning(runningPid)) {
+		pushLocalEvent(text.attached(runningPid));
+		return;
+	}
+
+	const childArgs = [ENGINE_FILE, '--headless'];
+	if (startPaused) childArgs.push('--paused');
+
+	pushLocalEvent(
+		startPaused ? text.startPaused : text.startRunning
+	);
+
+	spawnedEngine = spawn(process.execPath, childArgs, {
+		cwd: ROOT,
+		env: {
+			...process.env,
+			ORCHESTRATOR_WORKSPACE: ROOT,
+			NODE_PATH: [path.join(PACKAGE_ROOT, 'node_modules'), process.env.NODE_PATH]
+				.filter(Boolean)
+				.join(path.delimiter)
+		},
+		stdio: ['ignore', 'ignore', 'pipe'],
+		windowsHide: false
+	});
+
+	spawnedEngine.stderr.on('data', chunk => {
+		const text = normalizeInlineMessage(String(chunk));
+		if (text) pushLocalEvent(text);
+	});
+
+	spawnedEngine.on('exit', code => {
+		pushLocalEvent(text.engineExited(code));
+	});
+
+	spawnedEngine.on('error', error => {
+		pushLocalEvent(text.engineError(error.message));
+	});
+}
+
+function refresh() {
+	if (isResizing) return;
+
+	const snapshot = buildSnapshot();
+	if (!inkApp) {
+		inkApp = render(React.createElement(App, {snapshot, onAction: requestAction}), {
+			exitOnCtrlC: false,
+			patchConsole: false,
+			alternateScreen: true
+		});
+		return;
+	}
+
+	inkApp.rerender(React.createElement(App, {snapshot, onAction: requestAction}));
+}
+
+function clearTerminal() {
+	if (!process.stdout.isTTY) return;
+	process.stdout.write('\x1b[2J\x1b[3J\x1b[H');
+}
+
+function requestAction(action) {
+	const config = loadConfig();
+	const text = TEXT[languageFromConfig(config)];
+	switch (action) {
+		case 'start':
+			pushLocalEvent(text.resume);
+			sendControlCommand('start');
+			break;
+		case 'pause':
+			pushLocalEvent(text.pause);
+			sendControlCommand('pause');
+			break;
+		case 'reload':
+			pushLocalEvent(text.reload);
+			sendControlCommand('reload');
+			break;
+		case 'quit':
+			quitRequested = true;
+			pushLocalEvent(text.quit);
+			sendControlCommand('quit');
+			setTimeout(() => {
+				shutdown();
+				process.exit(0);
+			}, 500);
+			break;
+	}
+}
+
+function shutdown() {
+	if (refreshTimer) clearInterval(refreshTimer);
+	if (resizeTimer) clearTimeout(resizeTimer);
+	if (spawnedEngine && !spawnedEngine.killed && quitRequested) {
+		try {
+			spawnedEngine.kill('SIGTERM');
+		} catch {}
+	}
+	if (inkApp) inkApp.unmount();
+	// Limpiar archivos de control al salir
+	try { fs.unlinkSync(CONTROL_FILE); } catch {}
+	try { fs.unlinkSync(LOCK_FILE); } catch {}
+	try { fs.unlinkSync(STATE_FILE); } catch {}
+}
+
+function mount() {
+	ensureEngine();
+	refresh();
+	refreshTimer = setInterval(refresh, 1000);
+
+	if (process.stdout.isTTY) {
+		process.stdout.on('resize', () => {
+			const nextColumns = process.stdout.columns ?? 0;
+			const shrinking = nextColumns > 0 && lastColumns > 0 && nextColumns < lastColumns;
+			lastColumns = nextColumns;
+			isResizing = true;
+			if (resizeTimer) clearTimeout(resizeTimer);
+			resizeTimer = setTimeout(() => {
+				if (shrinking) {
+					clearTerminal();
+					if (inkApp) {
+						inkApp.unmount();
+						inkApp = null;
+					}
+				}
+				isResizing = false;
+				refresh();
+			}, 180);
+		});
+	}
+}
+
+process.on('SIGINT', () => {
+	requestAction('quit');
+});
+
+process.on('SIGTERM', () => {
+	requestAction('quit');
+});
+
+mount();

package/templates/en/.atl/skill-registry.md

@@ -0,0 +1,27 @@
+# Skill Registry
+
+**Project-local only.** This registry prioritizes skills inside `./.claude/skills/` so the workflow does not depend on global installations.
+
+## User Skills
+
+| Trigger | Skill | Path |
+|---------|-------|------|
+| manual | orchestrator-apply | `.claude/skills/orchestrator-apply/SKILL.md` |
+| manual | orchestrator-archive | `.claude/skills/orchestrator-archive/SKILL.md` |
+| manual | orchestrator-design | `.claude/skills/orchestrator-design/SKILL.md` |
+| manual | orchestrator-explore | `.claude/skills/orchestrator-explore/SKILL.md` |
+| manual | orchestrator-init | `.claude/skills/orchestrator-init/SKILL.md` |
+| manual | orchestrator-memory | `.claude/skills/orchestrator-memory/SKILL.md` |
+| manual | orchestrator-openspec | `.claude/skills/orchestrator-openspec/SKILL.md` |
+| manual | orchestrator-propose | `.claude/skills/orchestrator-propose/SKILL.md` |
+| manual | orchestrator-queue-planning | `.claude/skills/orchestrator-queue-planning/SKILL.md` |
+| manual | orchestrator-spec | `.claude/skills/orchestrator-spec/SKILL.md` |
+| manual | orchestrator-tasks | `.claude/skills/orchestrator-tasks/SKILL.md` |
+| manual | orchestrator-verify | `.claude/skills/orchestrator-verify/SKILL.md` |
+
+## Resolution Policy
+
+- Always prefer local skills from `./.claude/skills/`.
+- Do not depend on global skills for the main orchestrator workflow.
+- If a global skill has the same name, the project-local skill wins.
+- Regenerate this file after creating, deleting, or changing local skills.

package/templates/en/.claude/README.md

@@ -0,0 +1,7 @@
+# Claude Local Config
+
+This folder contains project-local Claude configuration.
+
+- `skills/` stores local orchestrator skills.
+- Root `CLAUDE.md` defines project routing.
+- Local config should take priority over global user config for this workflow.

package/templates/en/.claude/skills/orchestrator-apply/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: orchestrator-apply
+description: >
+  Guide the implementation phase by translating ready work into queued worker tasks.
+license: MIT
+metadata:
+  owner: agentflow
+  version: "1.0"
+---
+
+# Skill: orchestrator-apply
+
+## Purpose
+
+Run implementation through the orchestrator, not through the interactive Claude session.
+
+## Critical Rules
+
+- Read proposal, spec, design, tasks, and queue state when present.
+- Respect `QUEUE.md` as the execution boundary.
+- Do not implement code directly as Claude-Orchestrator.
+- Add or update TASKs so workers can implement.
+- Use Codex and OpenCode first when they fit the task.
+- Use Claude-Worker for fallback, extra capacity, broad implementation, or explicit user request.
+- Keep Claude as final reviewer.
+- Do not commit or push.
+- If implementation is partial, leave clear state for verify or the next apply pass.
+
+## Expected Result
+
+Implementation work is queued for workers and remains reviewable by Claude-Orchestrator.

package/templates/en/.claude/skills/orchestrator-archive/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: orchestrator-archive
+description: >
+  Close and archive a completed OpenSpec change after implementation and verification.
+license: MIT
+metadata:
+  owner: agentflow
+  version: "1.0"
+---
+
+# Skill: orchestrator-archive
+
+## Purpose
+
+Close a change with a durable summary of what was done and what remains.
+
+## Critical Rules
+
+- Confirm proposal, spec, design, tasks, and verify report are coherent.
+- Write or update `archive-report.md`.
+- Note completed work, remaining risks, and follow-ups.
+- Do not archive incomplete work as complete.
+
+## Expected Result
+
+A closed change with a useful archive report.

package/templates/en/.claude/skills/orchestrator-design/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: orchestrator-design
+description: >
+  Create or update the technical design for a change.
+license: MIT
+metadata:
+  owner: agentflow
+  version: "1.0"
+---
+
+# Skill: orchestrator-design
+
+## Purpose
+
+Document the technical approach, tradeoffs, affected files, risks, and rollout plan.
+
+## Critical Rules
+
+- Use `openspec/changes/<change-name>/design.md`.
+- Prefer existing project patterns.
+- Capture tradeoffs and risks clearly.
+- Keep design aligned with the proposal and spec.
+- Do not implement code directly.
+
+## Expected Result
+
+A technical design that can be broken into executable tasks.

package/templates/en/.claude/skills/orchestrator-explore/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: orchestrator-explore
+description: >
+  Explore, analyze, or investigate the project before proposing or delegating implementation.
+license: MIT
+metadata:
+  owner: agentflow
+  version: "1.0"
+---
+
+# Skill: orchestrator-explore
+
+## Purpose
+
+Gather useful context before creating TASKs or OpenSpec artifacts.
+
+## Critical Rules
+
+- Understand the user's exact scope first.
+- Prefer exploration before implementation when context is unclear.
+- Use OpenCode as the first support worker for broad reading, audits, and structured findings when appropriate.
+- Do not fill `QUEUE.md` with implementation tasks until enough context exists.
+- Summarize findings in actionable terms: what exists, what is missing, what risks exist, and what tasks follow.
+- If the change is large or multi-phase, move toward OpenSpec.
+- If work is clear, convert findings into concrete TASKs.
+
+## Expected Result
+
+The orchestrator can decide whether to plan TASKs or continue investigation.

package/templates/en/.claude/skills/orchestrator-init/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: orchestrator-init
+description: >
+  Initialize the orchestrator session: read ORCHESTRATOR.md, config, queue, progress, handoffs, and visible state before asking for the next priority.
+license: MIT
+metadata:
+  owner: agentflow
+  version: "1.0"
+---
+
+# Skill: orchestrator-init
+
+Trigger examples: "start", "start orchestrator", "read ORCHESTRATOR.md and start", "lee ORCHESTRATOR.md y arranca".
+
+## Purpose
+
+Prepare a new orchestrator session without executing project work directly.
+
+## Critical Rules
+
+- Read `ORCHESTRATOR.md` completely before responding.
+- Read `orchestrator.config.json` to understand repos, agents, and models.
+- Read `QUEUE.md` to detect pending, active, and completed work.
+- Read the newest handoff if present.
+- Read progress files if present.
+- Use `PROJECT.md` and `openspec/` as context when available.
+- Do not implement code during startup.
+- Reply that the orchestrator is ready and ask what the user wants to prioritize.
+
+## Expected Result
+
+Claude is ready as Claude-Orchestrator and has not performed project implementation directly.

package/templates/en/.claude/skills/orchestrator-memory/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: orchestrator-memory
+description: >
+  Use persistent memory for decisions, discoveries, bugs, setup notes, and session summaries.
+license: MIT
+metadata:
+  owner: agentflow
+  version: "1.0"
+---
+
+# Skill: orchestrator-memory
+
+## Purpose
+
+Preserve durable context for future sessions.
+
+## Critical Rules
+
+- Follow `ENGRAM.md`.
+- Save decisions, bug fixes, discoveries, setup changes, and session summaries.
+- Do not save secrets, credentials, API keys, or private customer data.
+- Memory complements `QUEUE.md`, OpenSpec, and handoffs. It does not replace them.
+
+## Expected Result
+
+Future sessions can resume with useful context instead of rediscovering everything.

package/templates/en/.claude/skills/orchestrator-openspec/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: orchestrator-openspec
+description: >
+  Create or update OpenSpec artifacts for large or multi-phase changes.
+license: MIT
+metadata:
+  owner: agentflow
+  version: "1.0"
+---
+
+# Skill: orchestrator-openspec
+
+## Purpose
+
+Use `openspec/` as the durable planning layer before delegating larger implementation work.
+
+## When To Use
+
+- Multi-phase changes
+- Multi-agent changes
+- User explicitly asks for proposal, spec, design, or tasks
+- The change needs durable traceability
+
+## Critical Rules
+
+- Create changes under `openspec/changes/<change-name>/`.
+- Use clear kebab-case change names.
+- Keep proposal, spec, design, tasks, verify report, and archive report consistent.
+- `tasks.md` should be translatable into `QUEUE.md`.
+- Do not queue large implementation work before the OpenSpec artifacts are clear.
+- Do not force OpenSpec for tiny direct changes.
+
+## Expected Result
+
+A coherent OpenSpec change that can feed the live queue.

package/templates/en/.claude/skills/orchestrator-propose/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: orchestrator-propose
+description: >
+  Create or update the proposal for a significant change before implementation.
+license: MIT
+metadata:
+  owner: agentflow
+  version: "1.0"
+---
+
+# Skill: orchestrator-propose
+
+## Purpose
+
+Define what the change is, why it matters, what is in scope, and what is explicitly out of scope.
+
+## Critical Rules
+
+- Read the user's request and current project context.
+- Use `openspec/changes/<change-name>/proposal.md`.
+- Keep the proposal short, actionable, and durable.
+- Do not implement code while writing the proposal.
+
+## Expected Result
+
+A proposal that can move into spec, design, tasks, and queue planning.