agentic-forge 0.0.0

package/src/commands/update.ts

@@ -0,0 +1,64 @@
+/** Update command handler. */
+
+import { execFileSync } from "node:child_process";
+
+import { getVersion } from "./version.js";
+
+function commandExists(cmd: string): boolean {
+	try {
+		execFileSync(process.platform === "win32" ? "where" : "which", [cmd], {
+			stdio: "ignore",
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export function cmdUpdate(options: { check?: boolean }): void {
+	const currentVersion = getVersion();
+	if (currentVersion === "unknown") {
+		process.stderr.write("Error: agentic-forge is not installed\n");
+		process.exit(1);
+	}
+
+	if (!commandExists("npm")) {
+		process.stderr.write("Error: npm is required for updating agentic-forge\n");
+		process.exit(1);
+	}
+
+	if (options.check) {
+		process.stdout.write(`Current version: ${currentVersion}\n`);
+		try {
+			const result = execFileSync("npm", ["view", "agentic-forge", "version"], {
+				encoding: "utf-8",
+				stdio: ["pipe", "pipe", "pipe"],
+			}).trim();
+			if (result && result !== currentVersion) {
+				process.stdout.write(`Latest version: ${result}\n`);
+			} else {
+				process.stdout.write("Already at the latest version.\n");
+			}
+		} catch {
+			process.stdout.write("Could not check for updates.\n");
+		}
+	} else {
+		process.stdout.write(`Current version: ${currentVersion}\n`);
+		process.stdout.write("Upgrading...\n");
+		try {
+			execFileSync("npm", ["install", "-g", "agentic-forge"], {
+				encoding: "utf-8",
+				stdio: ["pipe", "pipe", "pipe"],
+			});
+			const newVersion = getVersion();
+			if (newVersion !== currentVersion) {
+				process.stdout.write(`Successfully updated to version ${newVersion}\n`);
+			} else {
+				process.stdout.write("Already at the latest version.\n");
+			}
+		} catch {
+			process.stderr.write("Update failed.\n");
+			process.exit(1);
+		}
+	}
+}

package/src/commands/version.ts

@@ -0,0 +1,27 @@
+/** Version command handler. */
+
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export function cmdVersion(): void {
+	try {
+		const packageJsonPath = path.join(__dirname, "..", "..", "package.json");
+		const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8")) as { version: string };
+		process.stdout.write(`agentic-forge ${pkg.version}\n`);
+	} catch {
+		process.stdout.write("agentic-forge version unknown (package not installed)\n");
+	}
+}
+
+export function getVersion(): string {
+	try {
+		const packageJsonPath = path.join(__dirname, "..", "..", "package.json");
+		const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8")) as { version: string };
+		return pkg.version;
+	} catch {
+		return "unknown";
+	}
+}

package/src/commands/workflows.ts

@@ -0,0 +1,129 @@
+/** Workflows command handler. */
+
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import path from "node:path";
+import yaml from "js-yaml";
+
+import { getBundledWorkflowsDir, getProjectWorkflowsDir, getUserWorkflowsDir } from "./run.js";
+
+interface WorkflowMetadata {
+	name: string;
+	description: string;
+	variables: { name: string; required?: boolean }[];
+}
+
+function getWorkflowMetadata(filePath: string): WorkflowMetadata {
+	try {
+		const content = yaml.load(readFileSync(filePath, "utf-8")) as Record<string, unknown> | null;
+		if (!content || typeof content !== "object") {
+			return { name: path.basename(filePath, ".yaml"), description: "", variables: [] };
+		}
+		return {
+			name: (content.name as string) ?? path.basename(filePath, ".yaml"),
+			description: (content.description as string) ?? "",
+			variables: (content.variables as WorkflowMetadata["variables"]) ?? [],
+		};
+	} catch {
+		return { name: path.basename(filePath, ".yaml"), description: "", variables: [] };
+	}
+}
+
+function listAllWorkflows(): [string, string, string, WorkflowMetadata][] {
+	const workflows: [string, string, string, WorkflowMetadata][] = [];
+
+	const searchLocations: [string, string][] = [
+		[getProjectWorkflowsDir(), "project"],
+		[getUserWorkflowsDir(), "user"],
+		[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 fullPath = path.join(directory, file);
+				const metadata = getWorkflowMetadata(fullPath);
+				workflows.push([path.basename(file, ".yaml"), fullPath, locationType, metadata]);
+			}
+		}
+	}
+
+	return workflows;
+}
+
+export function cmdWorkflows(options: { verbose?: boolean }): void {
+	const workflows = listAllWorkflows();
+
+	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`);
+		process.stdout.write("\nUse 'agentic-forge init' to copy bundled workflows locally.\n");
+		return;
+	}
+
+	const verbose = options.verbose ?? false;
+
+	// Group by location
+	const byLocation: Record<string, [string, string, WorkflowMetadata][]> = {};
+	for (const [name, wfPath, location, metadata] of workflows) {
+		if (!byLocation[location]) {
+			byLocation[location] = [];
+		}
+		byLocation[location].push([name, wfPath, metadata]);
+	}
+
+	process.stdout.write("Available Workflows\n");
+	process.stdout.write(`${"=".repeat(50)}\n\n`);
+
+	const locationOrder = ["project", "user", "bundled"];
+	const locationLabels: Record<string, string> = {
+		project: "Project",
+		user: "User",
+		bundled: "Bundled",
+	};
+
+	for (const location of locationOrder) {
+		if (!byLocation[location]) {
+			continue;
+		}
+
+		process.stdout.write(`${locationLabels[location]}:\n`);
+		for (const [name, , metadata] of byLocation[location]) {
+			let desc = metadata.description;
+			if (desc) {
+				if (desc.length > 60 && !verbose) {
+					desc = `${desc.slice(0, 57)}...`;
+				}
+				process.stdout.write(`  ${name.padEnd(25)} ${desc}\n`);
+			} else {
+				process.stdout.write(`  ${name}\n`);
+			}
+
+			if (verbose && metadata.variables.length > 0) {
+				const required = metadata.variables.filter((v) => v.required).map((v) => v.name);
+				const optional = metadata.variables.filter((v) => !v.required).map((v) => v.name);
+				if (required.length > 0) {
+					process.stdout.write(`    Required: ${required.join(", ")}\n`);
+				}
+				if (optional.length > 0) {
+					process.stdout.write(`    Optional: ${optional.join(", ")}\n`);
+				}
+			}
+		}
+		process.stdout.write("\n");
+	}
+
+	process.stdout.write(`Total: ${workflows.length} workflow(s)\n\n`);
+	process.stdout.write("Usage:\n");
+	process.stdout.write("  agentic-forge run <workflow-name>\n");
+	process.stdout.write("  agentic-forge run <workflow-name> --var key=value\n\n");
+	process.stdout.write("Examples:\n");
+	process.stdout.write('  agentic-forge run one-shot --var task="Add login button"\n');
+	process.stdout.write("  agentic-forge run analyze-single --var analysis_type=bug\n");
+	process.stdout.write('  agentic-forge run plan-build-review --var task="Refactor auth"\n');
+}

package/src/config.ts

@@ -0,0 +1,129 @@
+/** Configuration management for agentic-forge. */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+const DEFAULT_CONFIG: Record<string, unknown> = {
+	outputDirectory: "agentic",
+	logging: {
+		enabled: true,
+		level: "Error",
+	},
+	git: {
+		mainBranch: "main",
+		autoCommit: true,
+		autoPr: true,
+	},
+	defaults: {
+		model: "sonnet",
+		maxRetry: 3,
+		timeoutMinutes: 60,
+		trackProgress: true,
+		terminalOutput: "base",
+	},
+	execution: {
+		maxWorkers: 4,
+		pollingIntervalSeconds: 5,
+	},
+};
+
+export function getConfigPath(repoRoot?: string): string {
+	const root = repoRoot ?? process.cwd();
+	return path.join(root, "agentic", "config.json");
+}
+
+export function getDefaultConfig(): Record<string, unknown> {
+	return deepCopy(DEFAULT_CONFIG);
+}
+
+export function loadConfig(repoRoot?: string): Record<string, unknown> {
+	const configPath = getConfigPath(repoRoot);
+
+	if (existsSync(configPath)) {
+		const content = readFileSync(configPath, "utf-8");
+		const userConfig = JSON.parse(content) as Record<string, unknown>;
+		return deepMerge(getDefaultConfig(), userConfig);
+	}
+
+	return getDefaultConfig();
+}
+
+export function saveConfig(config: Record<string, unknown>, repoRoot?: string): void {
+	const configPath = getConfigPath(repoRoot);
+	const dir = path.dirname(configPath);
+	mkdirSync(dir, { recursive: true });
+	writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+
+export function getConfigValue(key: string, repoRoot?: string): unknown {
+	const config = loadConfig(repoRoot);
+	const parts = key.split(".");
+	let value: unknown = config;
+	for (const part of parts) {
+		if (
+			value !== null &&
+			typeof value === "object" &&
+			!Array.isArray(value) &&
+			part in (value as Record<string, unknown>)
+		) {
+			value = (value as Record<string, unknown>)[part];
+		} else {
+			return null;
+		}
+	}
+	return value;
+}
+
+export function setConfigValue(key: string, value: string, repoRoot?: string): void {
+	const config = loadConfig(repoRoot);
+	const parts = key.split(".");
+	let target = config;
+	for (const part of parts.slice(0, -1)) {
+		if (!(part in target)) {
+			target[part] = {};
+		}
+		target = target[part] as Record<string, unknown>;
+	}
+
+	let parsedValue: unknown = value;
+	if (value.toLowerCase() === "true") {
+		parsedValue = true;
+	} else if (value.toLowerCase() === "false") {
+		parsedValue = false;
+	} else if (/^\d+$/.test(value)) {
+		parsedValue = Number.parseInt(value, 10);
+	}
+
+	target[parts[parts.length - 1]] = parsedValue;
+	saveConfig(config, repoRoot);
+}
+
+export function deepMerge(
+	base: Record<string, unknown>,
+	override: Record<string, unknown>,
+): Record<string, unknown> {
+	const result = { ...base };
+	for (const key of Object.keys(override)) {
+		if (
+			key in result &&
+			typeof result[key] === "object" &&
+			result[key] !== null &&
+			!Array.isArray(result[key]) &&
+			typeof override[key] === "object" &&
+			override[key] !== null &&
+			!Array.isArray(override[key])
+		) {
+			result[key] = deepMerge(
+				result[key] as Record<string, unknown>,
+				override[key] as Record<string, unknown>,
+			);
+		} else {
+			result[key] = override[key];
+		}
+	}
+	return result;
+}
+
+function deepCopy(obj: Record<string, unknown>): Record<string, unknown> {
+	return JSON.parse(JSON.stringify(obj)) as Record<string, unknown>;
+}