agent-watch 1.0.0

package/dist/cli.js

@@ -0,0 +1,771 @@
+#!/usr/bin/env node
+import { a as detectAgentFiles, c as loadConfig, f as FILE_SELECTION_PAGE_SIZE, g as SUPPORTED_AI_AGENTS, i as logger, l as saveConfig, m as KNOWN_AGENT_FILES, p as IGNORED_FILE_PATTERNS, r as processNewSessions, s as createDefaultConfig, u as AGENT_WATCH_DIR } from "./sessions-90kmJrQI.js";
+import { createRequire } from "node:module";
+import { program } from "commander";
+import { checkbox, confirm, select } from "@inquirer/prompts";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { execSync } from "node:child_process";
+import { homedir } from "node:os";
+
+//#region src/utils/git.ts
+/**
+* Find the git repository root from a given directory.
+* Returns null if not in a git repository.
+*/
+function findGitRoot(cwd = process.cwd()) {
+	try {
+		return execSync("git rev-parse --show-toplevel", {
+			cwd,
+			encoding: "utf-8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		}).trim();
+	} catch {
+		return null;
+	}
+}
+/**
+* Get the path to the .git/hooks directory.
+*/
+function getGitHooksDir(gitRoot) {
+	return join(gitRoot, ".git", "hooks");
+}
+/**
+* Check if lefthook is installed in the project.
+*/
+function hasLefthook(projectRoot) {
+	return existsSync(join(projectRoot, "lefthook.yml")) || existsSync(join(projectRoot, "lefthook.yaml"));
+}
+/**
+* Check if husky is installed in the project.
+*/
+function hasHusky(projectRoot) {
+	return existsSync(join(projectRoot, ".husky"));
+}
+/**
+* Get the path to lefthook.yml or lefthook.yaml.
+* Returns null if not found.
+*/
+function getLefthookPath(projectRoot) {
+	const ymlPath = join(projectRoot, "lefthook.yml");
+	const yamlPath = join(projectRoot, "lefthook.yaml");
+	if (existsSync(ymlPath)) return ymlPath;
+	if (existsSync(yamlPath)) return yamlPath;
+	return null;
+}
+/**
+* Check if lefthook CLI is available.
+*/
+function isLefthookAvailable() {
+	try {
+		execSync("npx lefthook version", {
+			stdio: "pipe",
+			timeout: 5e3
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Check if husky CLI is available.
+*/
+function isHuskyAvailable() {
+	try {
+		execSync("npx husky --version", {
+			stdio: "pipe",
+			timeout: 5e3
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/hooks.ts
+const HOOK_MARKER_START = "# >>> agent-watch hook start >>>";
+const HOOK_MARKER_END = "# <<< agent-watch hook end <<<";
+function getHookScript() {
+	return `${HOOK_MARKER_START}
+# agent-watch: auto-update agent configuration files
+npx agent-watch run 2>/dev/null || true
+${HOOK_MARKER_END}`;
+}
+/**
+* Validate basic lefthook.yml structure before attempting modification.
+* Checks: not empty, contains colons, no tabs, reasonable line/indentation length.
+*/
+function isValidLefthookStructure(content) {
+	if (!content.trim()) return false;
+	if (!content.includes(":")) return false;
+	if (content.includes("	")) return false;
+	const lines = content.split("\n");
+	if (lines.length > 1e3) return false;
+	for (const line of lines) {
+		if (line.length > 500) return false;
+		const leadingSpaces = line.search(/\S/);
+		if (leadingSpaces > 50 && leadingSpaces !== -1) return false;
+	}
+	return true;
+}
+/**
+* Remove existing agent-watch hook section from lefthook.yml content.
+* Removes ANY agent-watch: section to prevent duplicates.
+*/
+function removeExistingAgentWatchHook(lines) {
+	const result = [];
+	let inAgentWatchSection = false;
+	let sectionIndentation = 0;
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (trimmed.startsWith("agent-watch:")) {
+			inAgentWatchSection = true;
+			sectionIndentation = line.search(/\S/);
+			continue;
+		}
+		if (inAgentWatchSection) {
+			const currentIndent = line.search(/\S/);
+			if (currentIndent !== -1 && currentIndent <= sectionIndentation && trimmed.length > 0) {
+				inAgentWatchSection = false;
+				result.push(line);
+			}
+			continue;
+		}
+		result.push(line);
+	}
+	return result;
+}
+/**
+* Insert agent-watch command into lefthook.yml content.
+* Handles: missing hook section, missing commands section, proper indentation.
+*/
+function insertAgentWatchCommand(lines, hookName) {
+	const result = [];
+	let inserted = false;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		result.push(line);
+		if (line.trim() === `${hookName}:`) {
+			let commandsLineIndex = -1;
+			for (let j = i + 1; j < lines.length; j++) {
+				const trimmedLine = lines[j].trim();
+				if (trimmedLine.startsWith("commands:")) {
+					commandsLineIndex = j;
+					break;
+				}
+				if (trimmedLine && !lines[j].startsWith(" ")) break;
+			}
+			if (commandsLineIndex === -1) {
+				result.push("  commands:", "    agent-watch:", "      run: npx agent-watch run");
+				inserted = true;
+				continue;
+			}
+			for (let j = i + 1; j <= commandsLineIndex; j++) result.push(lines[j]);
+			result.push("    agent-watch:", "      run: npx agent-watch run");
+			inserted = true;
+			i = commandsLineIndex;
+		}
+	}
+	if (!inserted) return {
+		success: false,
+		error: `Could not find proper insertion point in lefthook.yml for ${hookName}`
+	};
+	return {
+		success: true,
+		content: result.join("\n")
+	};
+}
+/**
+* Update lefthook.yml content by adding/replacing agent-watch hook.
+* Coordinates removal and insertion, handles edge cases.
+*/
+function updateLefthookContent(content, hookName) {
+	const lines = content.split("\n");
+	const hasHookSection = new RegExp(`^${hookName}:\\s*$`, "m").test(content);
+	const withoutOldHook = removeExistingAgentWatchHook(lines);
+	if (!hasHookSection) {
+		const newSection = `
+${hookName}:
+  commands:
+    agent-watch:
+      run: npx agent-watch run
+`;
+		return {
+			success: true,
+			content: withoutOldHook.join("\n") + newSection
+		};
+	}
+	return insertAgentWatchCommand(withoutOldHook, hookName);
+}
+/**
+* Map the trigger name to the git hook file name.
+*/
+function getGitHookName(trigger) {
+	switch (trigger) {
+		case "commit": return "post-commit";
+		case "push": return "pre-push";
+	}
+}
+/**
+* Install agent-watch hook into lefthook.yml.
+* Flow: read file → validate → update content → write → run lefthook install
+*/
+function installLefthookHook(projectRoot, hookName) {
+	const lefthookPath = getLefthookPath(projectRoot);
+	if (!lefthookPath) return {
+		success: false,
+		message: "lefthook.yml not found",
+		method: "manual"
+	};
+	let currentContent;
+	try {
+		currentContent = readFileSync(lefthookPath, "utf-8");
+	} catch (error) {
+		return {
+			success: false,
+			message: `Cannot read lefthook.yml: ${error instanceof Error ? error.message : String(error)}. Please add manually:\n\n${hookName}:\n  commands:\n    agent-watch:\n      run: npx agent-watch run`,
+			method: "manual"
+		};
+	}
+	if (!(currentContent.trim().length === 0) && !isValidLefthookStructure(currentContent)) return {
+		success: true,
+		message: `lefthook.yml has complex structure. Please add manually:\n\n${hookName}:\n  commands:\n    agent-watch:\n      run: npx agent-watch run`,
+		method: "lefthook"
+	};
+	const result = updateLefthookContent(currentContent, hookName);
+	if (!result.success || !result.content) return {
+		success: false,
+		message: result.error || "Failed to update lefthook.yml",
+		method: "manual"
+	};
+	try {
+		const tempPath = `${lefthookPath}.tmp`;
+		writeFileSync(tempPath, result.content, "utf-8");
+		renameSync(tempPath, lefthookPath);
+	} catch (error) {
+		return {
+			success: false,
+			message: `Failed to write lefthook.yml: ${error instanceof Error ? error.message : String(error)}`,
+			method: "manual"
+		};
+	}
+	if (isLefthookAvailable()) try {
+		execSync("npx lefthook install", {
+			cwd: projectRoot,
+			stdio: "inherit",
+			timeout: 3e4
+		});
+		return {
+			success: true,
+			message: `Lefthook hook installed successfully in ${hookName}`,
+			method: "lefthook"
+		};
+	} catch (error) {
+		return {
+			success: true,
+			message: `Hook added to lefthook.yml. Failed to run lefthook install: ${error instanceof Error ? error.message : String(error)}\nPlease run: npx lefthook install`,
+			method: "lefthook"
+		};
+	}
+	return {
+		success: true,
+		message: "Hook added to lefthook.yml. Please run: npx lefthook install",
+		method: "lefthook"
+	};
+}
+/**
+* Install agent-watch hook using husky CLI.
+* Runs: npx husky add .husky/{hookName} "npx agent-watch run"
+*/
+function installHuskyHook(projectRoot, hookName) {
+	const huskyDir = join(projectRoot, ".husky");
+	if (!existsSync(huskyDir)) return {
+		success: false,
+		message: ".husky directory not found. Initialize husky first with: npx husky init",
+		method: "manual"
+	};
+	const hookPath = join(huskyDir, hookName);
+	if (existsSync(hookPath)) try {
+		if (readFileSync(hookPath, "utf-8").includes("agent-watch run")) return {
+			success: true,
+			message: `Husky hook already configured in .husky/${hookName}`,
+			method: "husky"
+		};
+	} catch {}
+	if (isHuskyAvailable()) try {
+		execSync(`npx husky add .husky/${hookName} "npx agent-watch run"`, {
+			cwd: projectRoot,
+			stdio: "pipe",
+			timeout: 3e4
+		});
+		return {
+			success: true,
+			message: `Husky hook installed successfully in .husky/${hookName}`,
+			method: "husky"
+		};
+	} catch {}
+	return {
+		success: true,
+		message: `Husky detected. Run: npx husky add .husky/${hookName} "npx agent-watch run"`,
+		method: "husky"
+	};
+}
+/**
+* Install the agent-watch hook into the git hooks directory.
+* If a hook file already exists, appends our section.
+* If lefthook or husky is detected, provides instructions instead.
+*/
+function installGitHook(projectRoot, gitRoot, trigger) {
+	const hookName = getGitHookName(trigger);
+	if (hasLefthook(projectRoot)) return installLefthookHook(projectRoot, hookName);
+	if (hasHusky(projectRoot)) return installHuskyHook(projectRoot, hookName);
+	const hooksDir = getGitHooksDir(gitRoot);
+	const hookPath = join(hooksDir, hookName);
+	try {
+		if (!existsSync(hooksDir)) mkdirSync(hooksDir, { recursive: true });
+		let hookContent;
+		if (existsSync(hookPath)) {
+			const existing = readFileSync(hookPath, "utf-8");
+			if (existing.includes(HOOK_MARKER_START)) {
+				const regex = new RegExp(`${escapeRegex(HOOK_MARKER_START)}[\\s\\S]*?${escapeRegex(HOOK_MARKER_END)}`);
+				hookContent = existing.replace(regex, getHookScript());
+			} else hookContent = `${existing.trimEnd()}\n\n${getHookScript()}\n`;
+		} else hookContent = `#!/bin/sh\n\n${getHookScript()}\n`;
+		writeFileSync(hookPath, hookContent, "utf-8");
+		chmodSync(hookPath, 493);
+		return {
+			success: true,
+			message: `Git ${hookName} hook installed successfully.`,
+			method: "direct"
+		};
+	} catch (error) {
+		return {
+			success: false,
+			message: `Failed to install git hook: ${error instanceof Error ? error.message : String(error)}`,
+			method: "manual"
+		};
+	}
+}
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+//#endregion
+//#region src/utils/copilot.ts
+const COPILOT_CONFIG_FILE = join(join(homedir(), ".copilot"), "config.json");
+/**
+* Check if the standalone GitHub Copilot CLI is installed
+*/
+function isCopilotInstalled() {
+	try {
+		const output = execSync("copilot -v", {
+			encoding: "utf-8",
+			stdio: "pipe"
+		});
+		return {
+			installed: true,
+			version: /(\d+\.\d+\.\d+)/.exec(output)?.[1]
+		};
+	} catch {
+		return { installed: false };
+	}
+}
+/**
+* Check if the user is authenticated with GitHub Copilot CLI
+* by reading the config file at ~/.copilot/config.json
+*/
+function getCopilotAuth() {
+	try {
+		if (!existsSync(COPILOT_CONFIG_FILE)) return { authenticated: false };
+		const configContent = readFileSync(COPILOT_CONFIG_FILE, "utf-8");
+		const config = JSON.parse(configContent);
+		if (config.logged_in_users && config.logged_in_users.length > 0) return {
+			authenticated: true,
+			username: (config.last_logged_in_user ?? config.logged_in_users[0]).login
+		};
+		return { authenticated: false };
+	} catch {
+		return { authenticated: false };
+	}
+}
+/**
+* Check the status of GitHub Copilot CLI
+*/
+function checkCopilotStatus() {
+	const { installed, version } = isCopilotInstalled();
+	const { authenticated, username } = getCopilotAuth();
+	return {
+		installed,
+		authenticated,
+		version,
+		username
+	};
+}
+/**
+* Prompt the user to install GitHub Copilot CLI
+*/
+async function promptInstallCopilot() {
+	logger.step("GitHub Copilot CLI is not installed. Please install it first:");
+	logger.info("  macOS: brew install gh-copilot");
+	logger.info("  npm:   npm install -g @githubnext/github-copilot-cli");
+	logger.info("  See:   https://docs.github.com/en/copilot/how-tos/copilot-cli");
+	logger.blank();
+	logger.info("After installation, please run 'agent-watch init' again.");
+	return false;
+}
+/**
+* Authenticate with GitHub Copilot CLI
+*/
+async function authenticateCopilot() {
+	try {
+		logger.step("Authenticating with GitHub Copilot CLI...");
+		logger.info("Follow the prompts to authenticate:");
+		execSync("copilot login", { stdio: "inherit" });
+		logger.success("GitHub Copilot CLI authenticated successfully!");
+		return true;
+	} catch (error) {
+		logger.error("Failed to authenticate with GitHub Copilot CLI");
+		logger.error(error instanceof Error ? error.message : String(error));
+		return false;
+	}
+}
+/**
+* Setup GitHub Copilot CLI - install and configure if needed
+*/
+async function setupGithubCopilotCli() {
+	const status = checkCopilotStatus();
+	if (!status.installed) return await promptInstallCopilot();
+	if (!status.authenticated) {
+		logger.warn("GitHub Copilot CLI is not authenticated");
+		if (!await authenticateCopilot()) return false;
+	} else logger.success(`Copilot CLI authenticated as ${status.username}`);
+	return true;
+}
+/**
+* Create missing agent files using Copilot CLI.
+* For .github/copilot-instructions.md, uses `copilot init`.
+* For other files, uses `copilot -p` to generate content based on the codebase.
+*/
+function createMissingAgentFiles(projectRoot, selectedFiles, detectedFiles) {
+	const missingFiles = selectedFiles.filter((filePath) => {
+		return !detectedFiles.find((d) => d.pattern.path === filePath)?.exists;
+	});
+	if (missingFiles.length === 0) return;
+	for (const filePath of missingFiles) {
+		const label = KNOWN_AGENT_FILES.find((f) => f.path === filePath)?.label ?? filePath;
+		try {
+			logger.step(`Creating ${label}...`);
+			if (filePath === ".github/copilot-instructions.md") execSync("copilot init", {
+				cwd: projectRoot,
+				stdio: "pipe",
+				timeout: 12e4
+			});
+			else execSync(`copilot -p "Create a ${filePath} file for this project. Analyze the codebase to understand the project structure, tech stack, and conventions. Write the file directly." --allow-all-tools -s`, {
+				cwd: projectRoot,
+				stdio: "pipe",
+				timeout: 12e4
+			});
+			logger.success(`Created ${label}`);
+		} catch {
+			logger.warn(`Failed to create ${label}`);
+		}
+	}
+}
+
+//#endregion
+//#region src/utils/gitignore.ts
+/**
+* Add entries to .gitignore if they don't already exist
+*/
+function addToGitignore(projectRoot, entries) {
+	const gitignorePath = join(projectRoot, ".gitignore");
+	if (!existsSync(projectRoot)) return;
+	let content = "";
+	if (existsSync(gitignorePath)) content = readFileSync(gitignorePath, "utf-8");
+	const lines = content.split("\n");
+	const entriesToAdd = [];
+	for (const entry of entries) if (!lines.some((line) => {
+		const trimmed = line.trim();
+		return trimmed === entry || trimmed === `/${entry}`;
+	})) entriesToAdd.push(entry);
+	if (entriesToAdd.length === 0) return;
+	const newContent = `${content.trim()}\n\n# agent-watch\n${entriesToAdd.join("\n")}\n`;
+	try {
+		writeFileSync(gitignorePath, newContent, "utf-8");
+	} catch {}
+}
+
+//#endregion
+//#region src/commands/init.ts
+async function initCommand() {
+	logger.asciiArt();
+	const gitRoot = findGitRoot(process.cwd());
+	if (!gitRoot) {
+		logger.error("Not inside a git repository. Please run this command from a git repository.");
+		process.exit(1);
+	}
+	const projectRoot = gitRoot;
+	if (loadConfig(projectRoot)) {
+		if (!await confirm({
+			message: "An existing agent-watch configuration was found. Do you want to overwrite it?",
+			default: false
+		})) {
+			logger.info("Init cancelled. Existing configuration preserved.");
+			return;
+		}
+	}
+	const detectedFiles = detectAgentFiles(projectRoot);
+	const existingFiles = detectedFiles.filter((f) => f.exists);
+	if (existingFiles.length > 0) logger.success(`Found ${existingFiles.length} existing agent file(s)`);
+	const selectedFiles = await checkbox({
+		message: "Which agent files should agent-watch manage?",
+		pageSize: FILE_SELECTION_PAGE_SIZE,
+		choices: KNOWN_AGENT_FILES.map((pattern) => {
+			const exists = detectedFiles.find((d) => d.pattern.path === pattern.path)?.exists ?? false;
+			return {
+				name: exists ? `  ${pattern.label} ✓` : `  ${pattern.label}`,
+				value: pattern.path,
+				checked: exists
+			};
+		})
+	});
+	if (selectedFiles.length === 0) {
+		logger.warn("No files selected. You can re-run 'agent-watch init' to configure.");
+		return;
+	}
+	createMissingAgentFiles(projectRoot, selectedFiles, detectedFiles);
+	const contextOptions = await checkbox({
+		message: "What should agent-watch track?",
+		choices: [{
+			name: "  File changes (git diff, modified files)",
+			value: "watchFileChanges",
+			checked: true
+		}, {
+			name: "  Chat sessions (Copilot conversation context)",
+			value: "includeChatSession",
+			checked: true
+		}]
+	});
+	const watchFileChanges = contextOptions.includes("watchFileChanges");
+	const includeChatSession = contextOptions.includes("includeChatSession");
+	const hookTrigger = await select({
+		message: "When should agent-watch trigger?",
+		choices: [{
+			name: "After git commit (post-commit hook)",
+			value: "commit"
+		}, {
+			name: "Before git push (pre-push hook)",
+			value: "push"
+		}],
+		default: "commit"
+	});
+	const selectedAgents = await checkbox({
+		message: "Which AI agents would you like to configure?",
+		choices: SUPPORTED_AI_AGENTS.map((agent) => ({
+			name: `  ${agent.name}`,
+			value: agent.value,
+			checked: true
+		}))
+	});
+	if (selectedAgents.includes("github-copilot-cli")) {
+		if (!await setupGithubCopilotCli()) logger.warn("Copilot CLI setup incomplete. You can set it up manually later.");
+	}
+	saveConfig(projectRoot, createDefaultConfig({
+		agentFiles: selectedFiles,
+		watchFileChanges,
+		includeChatSession,
+		hookTrigger,
+		agents: selectedAgents
+	}));
+	addToGitignore(projectRoot, [AGENT_WATCH_DIR]);
+	const hookResult = installGitHook(projectRoot, gitRoot, hookTrigger);
+	if (hookResult.success) if (hookResult.message.includes("Please run:") || hookResult.message.includes("please add manually")) logger.warn(hookResult.message);
+	else logger.success(hookResult.message);
+	else logger.error(hookResult.message);
+	logger.blank();
+	logger.success("Setup complete!");
+	logger.info(`Files: ${selectedFiles.join(", ")} • Hook: ${hookTrigger} • Agents: ${selectedAgents.join(", ")}`);
+	logger.blank();
+}
+
+//#endregion
+//#region src/commands/run.ts
+/**
+* Get git commit message
+*/
+function getCommitMessage() {
+	try {
+		return execSync("git log -1 --pretty=%B", {
+			encoding: "utf-8",
+			stdio: "pipe"
+		}).trim();
+	} catch {
+		return "";
+	}
+}
+/**
+* Get git diff stats (summary, not full diff)
+*/
+function getGitDiffStats() {
+	try {
+		return execSync("git diff HEAD~1..HEAD --stat", {
+			encoding: "utf-8",
+			stdio: "pipe"
+		}).trim();
+	} catch {
+		return "";
+	}
+}
+/**
+* Get list of modified files
+*/
+function getModifiedFiles() {
+	try {
+		return execSync("git diff --name-only HEAD~1..HEAD", {
+			encoding: "utf-8",
+			stdio: "pipe"
+		}).trim().split("\n").filter(Boolean);
+	} catch {
+		return [];
+	}
+}
+/**
+* Check if a file path should be ignored (doesn't trigger agent-watch analysis)
+*/
+function shouldIgnoreFile(filePath) {
+	const normalizedPath = filePath.replace(/\\/g, "/");
+	for (const pattern of IGNORED_FILE_PATTERNS) {
+		const normalizedPattern = pattern.replace(/\\/g, "/");
+		if (normalizedPath === normalizedPattern) return true;
+		if (normalizedPath.startsWith(`${normalizedPattern}/`)) return true;
+		if (normalizedPath.split("/").pop() === normalizedPattern) return true;
+	}
+	return false;
+}
+/**
+* Check if all modified files should be ignored
+*/
+function shouldSkipAnalysis(modifiedFiles) {
+	if (modifiedFiles.length === 0) return true;
+	return modifiedFiles.every(shouldIgnoreFile);
+}
+/**
+* Use Copilot CLI to intelligently update agent file content
+*/
+function updateAgentFileWithCopilot(projectRoot, context, agentFilePath, currentContent) {
+	try {
+		const output = execSync(`copilot -p "${`You are maintaining ${agentFilePath}, a living document of patterns, conventions, and code rules.
+
+Your task:
+1. Read the CURRENT content of this file carefully
+2. Analyze the RECENT changes and conversations below
+3. Determine if there are new patterns, rules, or conventions to document
+4. If updates are needed, output the COMPLETE UPDATED file content
+5. If no meaningful updates needed, output exactly: NO_UPDATE
+
+Guidelines:
+- Intelligently merge new insights into existing sections
+- Update or refine existing rules if patterns have evolved
+- Remove outdated information
+- Keep it concise - no code snippets unless absolutely necessary
+- Maintain the file's existing structure and tone
+- Focus on patterns, conventions, and learnings - not changelogs
+
+CURRENT FILE CONTENT:
+${currentContent}
+
+RECENT CONTEXT:
+${context}
+
+Output the complete updated file, or NO_UPDATE if nothing significant to add:`.replaceAll("\"", String.raw`\"`)}" -s`, {
+			cwd: projectRoot,
+			encoding: "utf-8",
+			stdio: "pipe",
+			timeout: 9e4
+		}).trim();
+		if (output === "NO_UPDATE" || output.length === 0 || output === currentContent) return null;
+		return output;
+	} catch {
+		return null;
+	}
+}
+/**
+* Run command - update agent files with extracted patterns and learnings
+*/
+async function runCommand() {
+	const gitRoot = findGitRoot(process.cwd());
+	if (!gitRoot) {
+		logger.error("Not inside a git repository");
+		process.exit(1);
+	}
+	const config = loadConfig(gitRoot);
+	if (!config) {
+		logger.error("No agent-watch configuration found. Run 'agent-watch init' first.");
+		process.exit(1);
+	}
+	if (config.agentFiles.length === 0) {
+		logger.warn("No agent files configured");
+		return;
+	}
+	const contextParts = [];
+	if (config.watchFileChanges) {
+		const modifiedFiles = getModifiedFiles();
+		if (shouldSkipAnalysis(modifiedFiles)) {
+			logger.info("Skipping analysis - only config/documentation files changed");
+			return;
+		}
+		const commitMessage = getCommitMessage();
+		const diffStats = getGitDiffStats();
+		if (modifiedFiles.length > 0) {
+			const fileContext = [
+				commitMessage ? `Commit: ${commitMessage}` : "",
+				`Files changed: ${modifiedFiles.join(", ")}`,
+				diffStats ? `Stats:\n${diffStats}` : ""
+			].filter(Boolean).join("\n");
+			contextParts.push(fileContext);
+		}
+	}
+	if (config.includeChatSession) {
+		const sessionContext = processNewSessions(gitRoot);
+		if (sessionContext) contextParts.push(`Conversations:\n${sessionContext}`);
+	}
+	if (contextParts.length === 0) {
+		logger.info("No new context to analyze");
+		return;
+	}
+	const context = contextParts.join("\n\n");
+	logger.step("Analyzing context for patterns and rules...");
+	let updatedCount = 0;
+	for (const filePath of config.agentFiles) {
+		const fullPath = join(gitRoot, filePath);
+		const updatedContent = updateAgentFileWithCopilot(gitRoot, context, filePath, readFileSync(fullPath, "utf-8"));
+		if (updatedContent) {
+			writeFileSync(fullPath, updatedContent, "utf-8");
+			logger.success(`Updated ${filePath}`);
+			updatedCount++;
+		}
+	}
+	if (updatedCount > 0) logger.success(`Updated ${updatedCount} agent file(s) with new insights`);
+	else logger.info("No significant patterns found to update");
+}
+
+//#endregion
+//#region src/cli.ts
+const { version } = createRequire(import.meta.url)("../package.json");
+program.name("agent-watch").description("Keep your AI agent configuration files in sync with your codebase").version(version);
+program.command("init").description("Initialize agent-watch in the current project").action(async () => {
+	await initCommand();
+});
+program.command("run").description("Update agent files with recent changes and chat sessions").action(async () => {
+	await runCommand();
+});
+program.parse();
+
+//#endregion
+export {  };
+//# sourceMappingURL=cli.js.map