agentic-forge 0.0.0

package/src/commands/init.ts

@@ -0,0 +1,96 @@
+/** Init and configure command handlers. */
+
+import { copyFileSync, existsSync, mkdirSync, readdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+import { getDefaultConfig, loadConfig } from "../config.js";
+import { getBundledWorkflowsDir } from "./run.js";
+
+export function cmdInit(options: { force?: boolean; listOnly?: boolean }): void {
+	const bundledDir = getBundledWorkflowsDir();
+	if (!existsSync(bundledDir)) {
+		process.stderr.write("Error: Bundled workflows directory not found.\n");
+		process.exit(1);
+	}
+
+	const bundledWorkflows = readdirSync(bundledDir)
+		.filter((f) => f.endsWith(".yaml"))
+		.sort();
+
+	if (bundledWorkflows.length === 0) {
+		process.stderr.write("No bundled workflows found.\n");
+		process.exit(1);
+	}
+
+	// List only mode
+	if (options.listOnly) {
+		process.stdout.write("Available bundled workflows:\n\n");
+		for (const wf of bundledWorkflows) {
+			process.stdout.write(`  ${wf}\n`);
+		}
+		process.stdout.write("\nUse 'agentic-forge init' to copy these to agentic/workflows/\n");
+		return;
+	}
+
+	// Copy workflows to local directory
+	const targetDir = path.join(process.cwd(), "agentic", "workflows");
+	mkdirSync(targetDir, { recursive: true });
+
+	const copied: string[] = [];
+	const skipped: string[] = [];
+	for (const wf of bundledWorkflows) {
+		const targetPath = path.join(targetDir, wf);
+		if (existsSync(targetPath) && !options.force) {
+			skipped.push(wf);
+		} else {
+			copyFileSync(path.join(bundledDir, wf), targetPath);
+			copied.push(wf);
+		}
+	}
+
+	if (copied.length > 0) {
+		process.stdout.write(`Copied ${copied.length} workflow(s) to ${targetDir}/\n`);
+		for (const name of copied) {
+			process.stdout.write(`  + ${name}\n`);
+		}
+	}
+
+	if (skipped.length > 0) {
+		process.stdout.write(`\nSkipped ${skipped.length} existing workflow(s):\n`);
+		for (const name of skipped) {
+			process.stdout.write(`  - ${name}\n`);
+		}
+		process.stdout.write("\nUse --force to overwrite existing files.\n");
+	}
+
+	// Create config.json next to workflows
+	initConfig(path.join(process.cwd(), "agentic"), options.force ?? false);
+
+	if (copied.length > 0) {
+		process.stdout.write("\nYou can now run workflows with:\n");
+		process.stdout.write("  agentic-forge run agentic/workflows/<workflow>.yaml\n");
+	}
+}
+
+function initConfig(agenticDir: string, force: boolean): void {
+	const configPath = path.join(agenticDir, "config.json");
+	if (existsSync(configPath) && !force) {
+		process.stdout.write(`\nConfig already exists: ${configPath}\n`);
+		return;
+	}
+
+	mkdirSync(agenticDir, { recursive: true });
+	const config = getDefaultConfig();
+	writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+	process.stdout.write(`\nCreated config: ${configPath}\n`);
+}
+
+export function cmdConfigure(): void {
+	const config = loadConfig();
+	process.stdout.write("Agentic Workflows Configuration\n");
+	process.stdout.write(`${"=".repeat(40)}\n`);
+	process.stdout.write("\nCurrent settings:\n");
+	process.stdout.write(`${JSON.stringify(config, null, 2)}\n`);
+	process.stdout.write("\nUse 'agentic-forge config set <key> <value>' to modify settings.\n");
+	process.stdout.write("Example: agentic-forge config set defaults.maxRetry 5\n");
+}

package/src/commands/release-notes.ts

@@ -0,0 +1,85 @@
+/** Release notes command handler. */
+
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export function cmdReleaseNotes(options: {
+	specificVersion?: string;
+	latest?: boolean;
+}): void {
+	let changelogPath: string | null = null;
+
+	// Try to find CHANGELOG.md relative to the package
+	const candidate = path.join(__dirname, "..", "..", "CHANGELOG.md");
+	if (existsSync(candidate)) {
+		changelogPath = candidate;
+	}
+
+	// Fallback: try current directory
+	if (changelogPath === null) {
+		const cwdCandidate = path.join(process.cwd(), "CHANGELOG.md");
+		if (existsSync(cwdCandidate)) {
+			changelogPath = cwdCandidate;
+		}
+	}
+
+	if (changelogPath === null) {
+		process.stdout.write("CHANGELOG.md not found\n");
+		return;
+	}
+
+	const content = readFileSync(changelogPath, "utf-8");
+
+	if (options.specificVersion) {
+		const section = extractVersionSection(content, options.specificVersion);
+		if (section) {
+			process.stdout.write(`${section.trim()}\n`);
+		} else {
+			process.stdout.write(`Version ${options.specificVersion} not found in CHANGELOG.md\n`);
+		}
+		return;
+	}
+
+	if (options.latest) {
+		const section = extractLatestVersion(content);
+		if (section) {
+			process.stdout.write(`${section.trim()}\n`);
+		} else {
+			process.stdout.write("No version information found in CHANGELOG.md\n");
+		}
+		return;
+	}
+
+	process.stdout.write(content);
+}
+
+function extractVersionSection(content: string, version: string): string | null {
+	const escaped = version.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const pattern = new RegExp(`^## \\[${escaped}\\].*$`, "m");
+	const match = pattern.exec(content);
+
+	if (!match) {
+		return null;
+	}
+
+	const start = match.index;
+	const nextPattern = /^## \[[\d.]+\]/m;
+	const nextMatch = nextPattern.exec(content.slice(match.index + match[0].length));
+	const end = nextMatch ? match.index + match[0].length + nextMatch.index : content.length;
+
+	return content.slice(start, end);
+}
+
+function extractLatestVersion(content: string): string | null {
+	const pattern = /^## \[([\d.]+)\].*$/m;
+	const match = pattern.exec(content);
+
+	if (!match) {
+		return null;
+	}
+
+	return extractVersionSection(content, match[1]);
+}

package/src/commands/resume.ts

@@ -0,0 +1,103 @@
+/** Resume command handler. */
+
+import { existsSync } from "node:fs";
+import path from "node:path";
+
+import { WORKFLOW_STATUS, loadProgress, prepareForResume, saveProgress } from "../progress.js";
+import { discoverWorkflow } from "./run.js";
+
+export async function cmdResume(options: {
+	workflowId: string;
+	terminalOutput?: string;
+}): Promise<void> {
+	const { WorkflowExecutor } = await import("../executor.js");
+	const { WorkflowParser, WorkflowParseError } = await import("../parser.js");
+
+	const progress = loadProgress(options.workflowId);
+	if (progress === null) {
+		process.stderr.write(`Error: Workflow not found: ${options.workflowId}\n`);
+		process.exit(1);
+	}
+
+	// Only reject completed workflows
+	if (progress.status === WORKFLOW_STATUS.COMPLETED) {
+		process.stderr.write(
+			`Error: Cannot resume a completed workflow (status: '${progress.status}')\n`,
+		);
+		process.exit(1);
+	}
+
+	// Resolve workflow YAML file
+	let workflowPath: string | null = null;
+
+	// Try stored workflow_file first
+	if (progress.workflowFile) {
+		if (existsSync(progress.workflowFile)) {
+			workflowPath = progress.workflowFile;
+		}
+	}
+
+	// Fall back to discovery by workflow name
+	if (workflowPath === null) {
+		const [discovered] = discoverWorkflow(progress.workflowName);
+		if (discovered !== null) {
+			workflowPath = discovered;
+		}
+	}
+
+	if (workflowPath === null) {
+		process.stderr.write(
+			`Error: Cannot find workflow file for '${progress.workflowName}'.\nProvide the workflow YAML at one of the standard locations or re-run with 'agentic-forge run <path>'.\n`,
+		);
+		process.exit(1);
+	}
+
+	// Parse workflow
+	let workflow: import("../types.js").WorkflowDefinition;
+	try {
+		const parser = new WorkflowParser();
+		workflow = parser.parseFile(workflowPath);
+	} catch (e) {
+		if (e instanceof WorkflowParseError) {
+			process.stderr.write(`Error parsing workflow: ${e.message}\n`);
+			process.exit(1);
+		}
+		throw e;
+	}
+
+	// Normalize state for resume
+	prepareForResume(progress);
+	saveProgress(progress);
+
+	// Execute with resume
+	const executor = new WorkflowExecutor();
+	try {
+		let terminalOutput = "base";
+		if (options.terminalOutput != null) {
+			terminalOutput = options.terminalOutput;
+		} else if (workflow.settings?.terminalOutput) {
+			terminalOutput = workflow.settings.terminalOutput;
+		}
+
+		const result = await executor.run(
+			workflow,
+			undefined,
+			null,
+			terminalOutput,
+			path.resolve(workflowPath),
+			progress,
+		);
+		process.stdout.write(`\nWorkflow ${result.status}: ${result.workflowId}\n`);
+		if (result.errors && result.errors.length > 0) {
+			process.stdout.write("\nErrors:\n");
+			for (const error of result.errors) {
+				process.stdout.write(
+					`  - ${(error as Record<string, string>).step}: ${(error as Record<string, string>).error}\n`,
+				);
+			}
+		}
+	} catch (e) {
+		process.stderr.write(`Error running workflow: ${(e as Error).message}\n`);
+		process.exit(1);
+	}
+}

package/src/commands/run.ts

@@ -0,0 +1,234 @@
+/** Run and resume command handlers with workflow discovery. */
+
+import { existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export function getBundledWorkflowsDir(): string {
+	return path.join(__dirname, "..", "workflows");
+}
+
+export function getUserWorkflowsDir(): string {
+	if (process.platform === "win32") {
+		const base = process.env.APPDATA ?? path.join(homedir(), "AppData", "Roaming");
+		return path.join(base, "agentic-forge", "workflows");
+	}
+	const base = process.env.XDG_CONFIG_HOME ?? path.join(homedir(), ".config");
+	return path.join(base, "agentic-forge", "workflows");
+}
+
+export function getProjectWorkflowsDir(): string {
+	return path.join(process.cwd(), "agentic", "workflows");
+}
+
+export function discoverWorkflow(name: string): [string | null, string] {
+	const fileName = name.endsWith(".yaml") ? name : `${name}.yaml`;
+
+	const searchLocations: [string, string][] = [
+		[getProjectWorkflowsDir(), "project-local"],
+		[getUserWorkflowsDir(), "user-global"],
+		[getBundledWorkflowsDir(), "bundled"],
+	];
+
+	for (const [directory, locationType] of searchLocations) {
+		const workflowPath = path.join(directory, fileName);
+		if (existsSync(workflowPath)) {
+			return [workflowPath, locationType];
+		}
+	}
+
+	return [null, "not found"];
+}
+
+export function listAvailableWorkflows(): [string, string, string][] {
+	const workflows: [string, string, string][] = [];
+
+	const searchLocations: [string, string][] = [
+		[getProjectWorkflowsDir(), "project-local"],
+		[getUserWorkflowsDir(), "user-global"],
+		[getBundledWorkflowsDir(), "bundled"],
+	];
+
+	for (const [directory, locationType] of searchLocations) {
+		if (existsSync(directory)) {
+			const files = readdirSync(directory)
+				.filter((f) => f.endsWith(".yaml"))
+				.sort();
+			for (const file of files) {
+				const name = path.basename(file, ".yaml");
+				workflows.push([name, path.join(directory, file), locationType]);
+			}
+		}
+	}
+
+	return workflows;
+}
+
+export function resolveWorkflowPath(workflowArg: string): [string, string] {
+	// Check if it's an absolute path
+	if (path.isAbsolute(workflowArg)) {
+		return [workflowArg, "absolute"];
+	}
+
+	// Check if it exists as a relative path from cwd
+	const localPath = path.resolve(process.cwd(), workflowArg);
+	if (existsSync(localPath)) {
+		return [localPath, "relative"];
+	}
+
+	// If the input looks like a bare name (no path separators), try discovery
+	if (!workflowArg.includes("/") && !workflowArg.includes("\\")) {
+		const [discovered, locationType] = discoverWorkflow(workflowArg);
+		if (discovered) {
+			return [discovered, locationType];
+		}
+	}
+
+	// Fallback: return the resolved path (will fail with appropriate error)
+	return [path.resolve(workflowArg), "not found"];
+}
+
+export async function cmdRun(options: {
+	workflow?: string;
+	listWorkflows?: boolean;
+	vars?: string[];
+	fromStep?: string;
+	terminalOutput?: string;
+}): Promise<void> {
+	// Handle --list flag
+	if (options.listWorkflows) {
+		process.stdout.write("Available workflows:\n\n");
+		const workflows = listAvailableWorkflows();
+
+		if (workflows.length === 0) {
+			process.stdout.write("No workflows found.\n");
+			process.stdout.write("\nSearched locations:\n");
+			process.stdout.write(`  - Project: ${getProjectWorkflowsDir()}\n`);
+			process.stdout.write(`  - User:    ${getUserWorkflowsDir()}\n`);
+			process.stdout.write(`  - Bundled: ${getBundledWorkflowsDir()}\n`);
+			return;
+		}
+
+		// Group by location
+		const byLocation: Record<string, [string, string][]> = {};
+		for (const [name, wfPath, location] of workflows) {
+			if (!byLocation[location]) {
+				byLocation[location] = [];
+			}
+			byLocation[location].push([name, wfPath]);
+		}
+
+		for (const location of ["project-local", "user-global", "bundled"]) {
+			if (byLocation[location]) {
+				const label = location.replace("-", " ").replace(/\b\w/g, (c) => c.toUpperCase());
+				process.stdout.write(`${label}:\n`);
+				for (const [name] of byLocation[location]) {
+					process.stdout.write(`  ${name}\n`);
+				}
+				process.stdout.write("\n");
+			}
+		}
+
+		process.stdout.write(`Total: ${workflows.length} workflow(s)\n`);
+		process.stdout.write("\nUsage: agentic-forge run <workflow-name>\n");
+		return;
+	}
+
+	// Validate workflow argument is provided
+	if (!options.workflow) {
+		process.stderr.write("Error: workflow name or path is required\n");
+		process.stderr.write("Use 'agentic-forge run --list' to see available workflows\n");
+		process.exit(1);
+	}
+
+	const { WorkflowExecutor } = await import("../executor.js");
+	const { WorkflowParser, WorkflowParseError } = await import("../parser.js");
+
+	const [workflowPath, locationType] = resolveWorkflowPath(options.workflow);
+
+	if (!existsSync(workflowPath)) {
+		process.stderr.write(`Error: Workflow not found: ${options.workflow}\n`);
+		process.stderr.write("\nAvailable workflows:\n");
+
+		const workflows = listAvailableWorkflows();
+		if (workflows.length > 0) {
+			for (const [name, , location] of workflows.slice(0, 10)) {
+				process.stderr.write(`  ${name} (${location})\n`);
+			}
+			if (workflows.length > 10) {
+				process.stderr.write(`  ... and ${workflows.length - 10} more\n`);
+			}
+		} else {
+			process.stderr.write("  (no workflows found)\n");
+		}
+
+		process.stderr.write("\nUse 'agentic-forge run --list' to see all workflows.\n");
+		process.stderr.write("Use 'agentic-forge init' to copy bundled workflows locally.\n");
+		process.exit(1);
+	}
+
+	// Show which workflow is being used
+	if (["project-local", "user-global", "bundled"].includes(locationType)) {
+		process.stdout.write(`Using ${locationType} workflow: ${path.basename(workflowPath)}\n`);
+	}
+
+	// Parse variables
+	const variables: Record<string, string> = {};
+	if (options.vars) {
+		for (const v of options.vars) {
+			if (!v.includes("=")) {
+				process.stderr.write(`Error: Invalid variable format: ${v}\n`);
+				process.stderr.write("Expected format: KEY=VALUE\n");
+				process.exit(1);
+			}
+			const eqIndex = v.indexOf("=");
+			variables[v.slice(0, eqIndex)] = v.slice(eqIndex + 1);
+		}
+	}
+
+	let workflow: import("../types.js").WorkflowDefinition;
+	try {
+		const parser = new WorkflowParser();
+		workflow = parser.parseFile(workflowPath);
+	} catch (e) {
+		if (e instanceof WorkflowParseError) {
+			process.stderr.write(`Error parsing workflow: ${e.message}\n`);
+			process.exit(1);
+		}
+		throw e;
+	}
+
+	const executor = new WorkflowExecutor();
+	try {
+		// Resolve terminal_output: CLI override > workflow settings > default "base"
+		let terminalOutput = "base";
+		if (options.terminalOutput != null) {
+			terminalOutput = options.terminalOutput;
+		} else if (workflow.settings?.terminalOutput) {
+			terminalOutput = workflow.settings.terminalOutput;
+		}
+
+		const progress = await executor.run(
+			workflow,
+			variables,
+			options.fromStep ?? null,
+			terminalOutput,
+			path.resolve(workflowPath),
+		);
+		process.stdout.write(`\nWorkflow ${progress.status}: ${progress.workflowId}\n`);
+		if (progress.errors && progress.errors.length > 0) {
+			process.stdout.write("\nErrors:\n");
+			for (const error of progress.errors) {
+				process.stdout.write(
+					`  - ${(error as Record<string, string>).step}: ${(error as Record<string, string>).error}\n`,
+				);
+			}
+		}
+	} catch (e) {
+		process.stderr.write(`Error running workflow: ${(e as Error).message}\n`);
+		process.exit(1);
+	}
+}

package/src/commands/shortcuts.ts

@@ -0,0 +1,11 @@
+/** Shortcut command handlers (input). */
+
+import { processHumanInput } from "../orchestrator.js";
+
+export function cmdInput(workflowId: string, response: string): void {
+	if (processHumanInput(workflowId, response)) {
+		process.stdout.write(`Input recorded for workflow: ${workflowId}\n`);
+	} else {
+		process.exit(1);
+	}
+}

package/src/commands/skills-dir.ts

@@ -0,0 +1,11 @@
+/** Skills-dir command handler. */
+
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export function cmdSkillsDir(): void {
+	const skillsDir = path.resolve(path.join(__dirname, "..", "claude"));
+	process.stdout.write(`${skillsDir}\n`);
+}

package/src/commands/status.ts

@@ -0,0 +1,112 @@
+/** Status, cancel, and list command handlers. */
+
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import path from "node:path";
+
+import { WORKFLOW_STATUS, loadProgress, saveProgress } from "../progress.js";
+
+export function cmdStatus(workflowId: string): void {
+	const progress = loadProgress(workflowId);
+	if (progress === null) {
+		process.stderr.write(`Error: Workflow not found: ${workflowId}\n`);
+		process.exit(1);
+	}
+
+	process.stdout.write(`Workflow: ${progress.workflowName}\n`);
+	process.stdout.write(`ID: ${progress.workflowId}\n`);
+	process.stdout.write(`Status: ${progress.status}\n`);
+	process.stdout.write(`Started: ${progress.startedAt}\n`);
+	if (progress.completedAt) {
+		process.stdout.write(`Completed: ${progress.completedAt}\n`);
+	}
+
+	if (progress.currentStep) {
+		const step = progress.currentStep as Record<string, unknown>;
+		process.stdout.write(`\nCurrent Step: ${step.name}\n`);
+		process.stdout.write(`  Retry Count: ${(step.retry_count as number) ?? 0}\n`);
+	}
+
+	if (progress.completedSteps && progress.completedSteps.length > 0) {
+		process.stdout.write("\nCompleted Steps:\n");
+		for (const step of progress.completedSteps) {
+			const icon = step.status === "completed" ? "+" : "x";
+			process.stdout.write(`  [${icon}] ${step.name}\n`);
+		}
+	}
+
+	if (progress.pendingSteps && progress.pendingSteps.length > 0) {
+		process.stdout.write("\nPending Steps:\n");
+		for (const stepName of progress.pendingSteps) {
+			process.stdout.write(`  [ ] ${stepName}\n`);
+		}
+	}
+
+	if (progress.errors && progress.errors.length > 0) {
+		process.stdout.write("\nErrors:\n");
+		for (const error of progress.errors) {
+			const err = error as Record<string, string>;
+			process.stdout.write(`  - ${err.step}: ${err.error}\n`);
+		}
+	}
+}
+
+export function cmdCancel(workflowId: string): void {
+	const progress = loadProgress(workflowId);
+	if (progress === null) {
+		process.stderr.write(`Error: Workflow not found: ${workflowId}\n`);
+		process.exit(1);
+	}
+
+	if (progress.status !== WORKFLOW_STATUS.RUNNING && progress.status !== WORKFLOW_STATUS.PAUSED) {
+		process.stderr.write(`Error: Cannot cancel workflow in '${progress.status}' status\n`);
+		process.exit(1);
+	}
+
+	progress.status = WORKFLOW_STATUS.CANCELED;
+	progress.completedAt = new Date().toISOString();
+	saveProgress(progress);
+
+	process.stdout.write(`Workflow canceled: ${workflowId}\n`);
+}
+
+export function cmdList(statusFilter?: string): void {
+	const outputsDir = path.join(process.cwd(), "agentic", "outputs");
+	if (!existsSync(outputsDir)) {
+		process.stdout.write("No workflows found.\n");
+		return;
+	}
+
+	const workflows: Record<string, unknown>[] = [];
+	const entries = readdirSync(outputsDir, { withFileTypes: true });
+	for (const entry of entries) {
+		if (entry.isDirectory()) {
+			const progressFile = path.join(outputsDir, entry.name, "progress.json");
+			if (existsSync(progressFile)) {
+				const data = JSON.parse(readFileSync(progressFile, "utf-8")) as Record<string, unknown>;
+				if (statusFilter == null || data.status === statusFilter) {
+					workflows.push(data);
+				}
+			}
+		}
+	}
+
+	if (workflows.length === 0) {
+		const suffix = statusFilter ? ` (status=${statusFilter})` : "";
+		process.stdout.write(`No workflows found.${suffix}\n`);
+		return;
+	}
+
+	process.stdout.write(
+		`${"ID".padEnd(12)} ${"Name".padEnd(25)} ${"Status".padEnd(12)} ${"Started".padEnd(20)}\n`,
+	);
+	process.stdout.write(`${"-".repeat(70)}\n`);
+	for (const wf of workflows) {
+		const id = String(wf.workflow_id ?? "").padEnd(12);
+		const name = String(wf.workflow_name ?? "")
+			.slice(0, 25)
+			.padEnd(25);
+		const status = String(wf.status ?? "").padEnd(12);
+		const started = wf.started_at ? String(wf.started_at).slice(0, 19).padEnd(20) : "".padEnd(20);
+		process.stdout.write(`${id} ${name} ${status} ${started}\n`);
+	}
+}