@liriraid/agentflow-ai 1.0.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LiriRaid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,79 @@
+# agentflow
+
+Reusable multi-agent orchestration workspace for coding projects.
+
+This package installs a CLI that creates a separate orchestrator workspace next to your real project. The generated workspace can be created in **English** or **Spanish**.
+
+```text
+my-product-workspace/
+  my-product/                 # real project, stays clean
+  orchestrator-my-product/    # generated orchestrator workspace
+```
+
+## Install
+
+```bash
+npm i -g @liriraid/agentflow
+```
+
+## Create a Workspace
+
+Interactive language selection:
+
+```bash
+agentflow init-workspace C:/code/my-project
+```
+
+Direct language selection:
+
+```bash
+agentflow init-workspace C:/code/my-project --lang en
+agentflow init-workspace C:/code/mi-proyecto --lang es
+```
+
+The selected language controls the generated workspace files:
+
+- `ORCHESTRATOR.md`
+- `CLAUDE.md`
+- `QUEUE.md`
+- `PROJECT.md`
+- `README.md`
+- `agents/`
+- `docs/`
+- `openspec/`
+- `.claude/`
+- `.codex/`
+- `.opencode/`
+- `.atl/`
+- `orchestrator.config.json`
+
+## Runtime
+
+The package runtime remains language-aware through `workspaceLanguage` in the generated `orchestrator.config.json`.
+
+Start the TUI from the generated orchestrator workspace:
+
+```bash
+cd C:/code/orchestrator-my-project
+agentflow ink --paused
+```
+
+Then open Claude Code in the same workspace and start with the prompt from that workspace's `ORCHESTRATOR.md`.
+
+## What Gets Packaged
+
+The npm package ships:
+
+- `bin/`
+- `src/`
+- `scripts/`
+- `templates/en/`
+- `templates/es/`
+- `orchestrator.js`
+- `LICENSE`
+
+The workspace docs and prompts live inside `templates/en` and `templates/es`; they are copied into the generated workspace based on the selected language.
+
+## Acknowledgements
+
+Inspired by [Orquestador-AI](https://github.com/ariellontero/Orquestador-AI) by Ariel Lontero (originally MIT). Built from scratch with a different architecture (Ink TUI, npm package, multi-language template system).

package/bin/agentflow.mjs

@@ -0,0 +1,332 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import {fileURLToPath} from 'url';
+import {spawn} from 'child_process';
+import {createInterface} from 'readline/promises';
+import {stdin as input, stdout as output} from 'process';
+
+const __filename = fileURLToPath(import.meta.url);
+const PACKAGE_ROOT = path.dirname(path.dirname(__filename));
+const argv = process.argv.slice(2);
+
+const TEMPLATE_PATHS = [
+	'README.md',
+	'ORCHESTRATOR.md',
+	'CLAUDE.md',
+	'ENGRAM.md',
+	'AGENT-CONFIG.md',
+	'PROJECT.md',
+	'.atl',
+	'docs',
+	'orchestrator.config.json',
+	'QUEUE.md',
+	'agents',
+	'openspec',
+	'.claude',
+	'.codex',
+	'.opencode'
+];
+
+const RUNTIME_DIRS = ['logs', 'handoffs', 'progress', 'briefs'];
+const SUPPORTED_LANGUAGES = new Set(['en', 'es']);
+const DEFAULT_LANGUAGE = 'en';
+const TEXT = {
+	es: {
+		unsupported: value => `Idioma no soportado: ${value}. Usa "en" o "es".`,
+		missingTemplate: language => `No existe el template de idioma: ${language}`,
+		installed: target => `Orquestador instalado en ${target}`,
+		language: language => `Idioma del workspace: ${language.toUpperCase()}`,
+		next: 'Siguiente paso recomendado:',
+		step1: '1. Edita orchestrator.config.json con rutas reales',
+		step2: '2. Revisa ORCHESTRATOR.md, CLAUDE.md y docs/',
+		step3: '3. Ejecuta: agentflow ink --paused',
+		invalidProject: projectPath => `Ruta de proyecto inválida: ${projectPath}`,
+		realProject: projectPath => `Proyecto real: ${projectPath}`,
+		workspace: workspaceDir => `Workspace del orquestador: ${workspaceDir}`,
+		sibling:
+			'Este workspace queda fuera del repo del proyecto, como sibling, para no ensuciarlo con archivos del orquestador.',
+		unknown: command => `Comando desconocido: ${command}`
+	},
+	en: {
+		unsupported: value => `Unsupported language: ${value}. Use "en" or "es".`,
+		missingTemplate: language => `Language template not found: ${language}`,
+		installed: target => `Orchestrator installed at ${target}`,
+		language: language => `Workspace language: ${language.toUpperCase()}`,
+		next: 'Recommended next steps:',
+		step1: '1. Edit orchestrator.config.json with real paths',
+		step2: '2. Review ORCHESTRATOR.md, CLAUDE.md, and docs/',
+		step3: '3. Run: agentflow ink --paused',
+		invalidProject: projectPath => `Invalid project path: ${projectPath}`,
+		realProject: projectPath => `Real project: ${projectPath}`,
+		workspace: workspaceDir => `Orchestrator workspace: ${workspaceDir}`,
+		sibling:
+			'This workspace stays next to the real project as a sibling, so orchestrator files do not pollute the product repo.',
+		unknown: command => `Unknown command: ${command}`
+	}
+};
+
+function printHelp() {
+	console.log(`
+agentflow
+
+Uso:
+  agentflow init [targetDir] [--project-name <name>] [--backend <path>] [--frontend <path>] [--lang <en|es>] [--force]
+  agentflow init-workspace <projectPath> [--workspace-name <name>] [--backend <path>] [--frontend <path>] [--lang <en|es>] [--force]
+  agentflow tui [--paused] [--yolo]
+  agentflow ink [--paused] [--yolo]
+  agentflow skills:registry
+  agentflow openspec:new <change-name>
+  agentflow agent-config:init
+
+Ejemplos:
+  agentflow init . --project-name "Mi Proyecto" --lang es
+  agentflow init-workspace C:/code/mi-proyecto --lang en
+  agentflow tui --paused
+  agentflow ink
+`);
+}
+
+function parseFlags(args) {
+	const flags = {};
+	const rest = [];
+
+	for (let i = 0; i < args.length; i += 1) {
+		const current = args[i];
+		if (!current.startsWith('--')) {
+			rest.push(current);
+			continue;
+		}
+
+		const key = current.slice(2);
+		const next = args[i + 1];
+		if (!next || next.startsWith('--')) {
+			flags[key] = true;
+			continue;
+		}
+
+		flags[key] = next;
+		i += 1;
+	}
+
+	return {flags, rest};
+}
+
+function normalizeLanguage(value) {
+	if (!value || value === true) return null;
+	const normalized = String(value).trim().toLowerCase();
+	if (normalized === '1' || normalized === 'en' || normalized === 'english') return 'en';
+	if (normalized === '2' || normalized === 'es' || normalized === 'spanish' || normalized === 'espanol' || normalized === 'español') return 'es';
+	return null;
+}
+
+async function resolveLanguage(flagValue) {
+	const fromFlag = normalizeLanguage(flagValue);
+	if (fromFlag) return fromFlag;
+
+	if (flagValue && !fromFlag) {
+		console.warn(TEXT.es.unsupported(flagValue));
+	}
+
+	if (!process.stdin.isTTY || !process.stdout.isTTY) return DEFAULT_LANGUAGE;
+
+	const rl = createInterface({input, output});
+	try {
+		console.log('');
+		console.log('Selecciona el idioma del workspace / Select workspace language:');
+		console.log('  1) EN - English (recommended for AI agents)');
+		console.log('  2) ES - Español');
+		const answer = await rl.question(`Language [${DEFAULT_LANGUAGE}]: `);
+		return normalizeLanguage(answer) || DEFAULT_LANGUAGE;
+	} finally {
+		rl.close();
+	}
+}
+
+function ensureDir(dir) {
+	fs.mkdirSync(dir, {recursive: true});
+}
+
+function copyRecursive(source, target, force = false) {
+	const stats = fs.statSync(source);
+
+	if (stats.isDirectory()) {
+		if (path.basename(source) === 'node_modules') return;
+		ensureDir(target);
+		for (const entry of fs.readdirSync(source)) {
+			copyRecursive(path.join(source, entry), path.join(target, entry), force);
+		}
+		return;
+	}
+
+	if (fs.existsSync(target) && !force) return;
+	ensureDir(path.dirname(target));
+	fs.copyFileSync(source, target);
+}
+
+function patchGitignore(targetDir) {
+	const gitignorePath = path.join(targetDir, '.gitignore');
+	const entries = ['.atl/', 'logs/', 'handoffs/', 'progress/', 'briefs/'];
+
+	let existing = '';
+	if (fs.existsSync(gitignorePath)) {
+		existing = fs.readFileSync(gitignorePath, 'utf8');
+	}
+
+	const toAdd = entries.filter(e => !existing.includes(e));
+	if (toAdd.length === 0) return;
+
+	const trailingNewline = existing.endsWith('\n') ? '' : '\n';
+	const block = `${trailingNewline}\n### agentflow\n${toAdd.join('\n')}\n`;
+	fs.writeFileSync(gitignorePath, existing + block, 'utf8');
+}
+
+function patchConfig(targetDir, options) {
+	const configPath = path.join(targetDir, 'orchestrator.config.json');
+	if (!fs.existsSync(configPath)) return;
+
+	const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+	const projectName = options.projectName || path.basename(path.resolve(targetDir)) || config.projectName;
+	config.projectName = projectName;
+	config.workspaceLanguage = options.language;
+
+	if (options.backend) {
+		config.repos.backend = options.backend;
+	}
+
+	if (options.frontend) {
+		config.repos.frontend = options.frontend;
+	}
+
+	fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+}
+
+async function initProject(args) {
+	const {flags, rest} = parseFlags(args);
+	const targetDir = path.resolve(rest[0] || '.');
+	const force = Boolean(flags.force);
+	const language = await resolveLanguage(flags.lang);
+	const templateRoot = path.join(PACKAGE_ROOT, 'templates', language);
+
+	if (!fs.existsSync(templateRoot)) {
+		console.error(TEXT[language].missingTemplate(language));
+		process.exit(1);
+	}
+
+	ensureDir(targetDir);
+
+	for (const relativePath of TEMPLATE_PATHS) {
+		const source = path.join(templateRoot, relativePath);
+		if (!fs.existsSync(source)) continue;
+		const target = path.join(targetDir, relativePath);
+		copyRecursive(source, target, force);
+	}
+
+	for (const dir of RUNTIME_DIRS) {
+		ensureDir(path.join(targetDir, dir));
+	}
+
+	patchConfig(targetDir, {
+		projectName: flags['project-name'],
+		backend: flags.backend,
+		frontend: flags.frontend,
+		language
+	});
+
+	patchGitignore(targetDir);
+
+	const text = TEXT[language];
+	console.log(text.installed(targetDir));
+	console.log(text.language(language));
+	console.log(text.next);
+	console.log(text.step1);
+	console.log(text.step2);
+	console.log(text.step3);
+}
+
+async function initWorkspace(args) {
+	const {flags, rest} = parseFlags(args);
+	const projectPath = path.resolve(rest[0] || '.');
+	const language = await resolveLanguage(flags.lang);
+
+	if (!fs.existsSync(projectPath) || !fs.statSync(projectPath).isDirectory()) {
+		console.error(TEXT[language].invalidProject(projectPath));
+		process.exit(1);
+	}
+
+	const projectName = flags['project-name'] || path.basename(projectPath);
+	const workspaceName = flags['workspace-name'] || `orchestrator-${projectName.toLowerCase().replace(/\s+/g, '-')}`;
+	const workspaceDir = path.join(path.dirname(projectPath), workspaceName);
+
+	await initProject([
+		workspaceDir,
+		'--project-name',
+		projectName,
+		'--lang',
+		language,
+		'--backend',
+		flags.backend || projectPath,
+		'--frontend',
+		flags.frontend || projectPath,
+		...(flags.force ? ['--force'] : [])
+	]);
+
+	console.log('');
+	console.log(TEXT[language].realProject(projectPath));
+	console.log(TEXT[language].workspace(workspaceDir));
+	console.log(TEXT[language].sibling);
+}
+
+function runNodeScript(relativeScript, args = []) {
+	const scriptPath = path.join(PACKAGE_ROOT, relativeScript);
+	const child = spawn(process.execPath, [scriptPath, ...args], {
+		cwd: process.cwd(),
+		env: {
+			...process.env,
+			ORCHESTRATOR_WORKSPACE: process.cwd(),
+			NODE_PATH: [path.join(PACKAGE_ROOT, 'node_modules'), process.env.NODE_PATH]
+				.filter(Boolean)
+				.join(path.delimiter)
+		},
+		stdio: 'inherit'
+	});
+
+	child.on('exit', code => process.exit(code ?? 0));
+}
+
+const command = argv[0];
+
+switch (command) {
+	case undefined:
+	case 'help':
+	case '--help':
+	case '-h':
+		printHelp();
+		break;
+	case 'init':
+		await initProject(argv.slice(1));
+		break;
+	case 'init-workspace':
+		await initWorkspace(argv.slice(1));
+		break;
+	case 'tui':
+		runNodeScript('orchestrator.js', argv.slice(1));
+		break;
+	case 'ink':
+		runNodeScript(path.join('src', 'ink', 'index.mjs'), argv.slice(1));
+		break;
+	case 'skills:registry':
+		runNodeScript(path.join('scripts', 'update-skill-registry.mjs'));
+		break;
+	case 'openspec:new':
+		runNodeScript(path.join('scripts', 'scaffold-openspec-change.mjs'), argv.slice(1));
+		break;
+	case 'agent-config:init':
+		runNodeScript(path.join('scripts', 'scaffold-agent-configs.mjs'));
+		break;
+	default:
+		console.error(TEXT.es.unknown(command));
+		printHelp();
+		process.exit(1);
+}