centient 2.20.0 → 2.25.0

package/dist/cli.js

@@ -0,0 +1,816 @@
+import { readFileSync, existsSync, watch, statSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import { listInstances, getAggregatedStats, formatUptime, isHeartbeatStale, } from "./utils/InstanceRegistry.js";
+import { getAuditLogPath as getConfigAuditLogPath, getMetaKnowledgeConfig } from "./utils/config.js";
+import { getSharedPatternsPath } from "./utils/filesystem.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function getVersion() {
+    try {
+        const packagePath = join(__dirname, "..", "package.json");
+        const pkg = JSON.parse(readFileSync(packagePath, "utf-8"));
+        return pkg.version || "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+export function printVersion() {
+    console.log(`centient ${getVersion()}`);
+}
+export function printHelp() {
+    const version = getVersion();
+    console.log(`centient v${version} - MCP server for context engineering
+
+Usage: centient [command] [options]
+
+Commands:
+  init                    Initialize .claude/ directory with commands
+  check-commands          Show missing/outdated commands
+  update-commands         Update outdated commands
+
+Options:
+  -V, --version           Show version number
+  -h, --help              Show this help message
+  -l, --list-tools        List all available MCP tools
+      --health            Run health check and exit
+      --config            Show current configuration
+      --stats             Show usage statistics and exit
+      --force             Force overwrite (for init/update-commands)
+      --dry-run           Show what would be updated without making changes
+
+Instance Monitoring (like ps):
+      --monitor           List all running centient instances
+  -p, --project <name>    Filter instances by project name
+  -f, --follow            Watch for activity in real-time
+  -j, --json              Output in JSON format
+  -q, --quiet             Output just PIDs (for scripting)
+  -s, --summary           Show aggregate statistics only
+
+Audit Log (per-project):
+      --log               Tail local audit log
+      --last <n>          Show last n events (default: 20)
+  -f, --follow            Continuous tailing mode
+
+Running without arguments starts the MCP server (stdio transport).
+
+Examples:
+  centient init                   # Initialize project with commands
+  centient init --force           # Overwrite existing commands
+  centient check-commands         # Check command status
+  centient update-commands        # Update outdated commands
+  centient update-commands --dry-run  # Preview what would be updated
+  centient --monitor              # Show all running instances
+  centient --monitor -f           # Watch activity across all instances
+  centient --log --last 50        # Show last 50 audit log events
+
+Documentation: https://github.com/Szermer/centient
+`);
+}
+export function printTools(tools) {
+    const version = getVersion();
+    console.log(`centient v${version} - Available MCP Tools (${tools.length} total)\n`);
+    const modules = {};
+    for (const tool of tools) {
+        let module = "other";
+        const name = tool.name;
+        if (name.includes("Pattern") || name.includes("Skill") || name === "findPatterns") {
+            module = "patterns";
+        }
+        else if (name.includes("Artifact") || (name.includes("Session") && name.includes("load"))) {
+            module = "artifacts";
+        }
+        else if (name.includes("Note") || name === "getDecisions" || name === "getHypotheses") {
+            module = "memory";
+        }
+        else if (name.includes("Compression") || name.includes("Reuse") || name.includes("Cost") || name.includes("Analytics") || name.includes("Audit")) {
+            module = "metrics";
+        }
+        else if (name.includes("semantic") || (name.includes("index") && name.includes("Session")) || name.includes("SearchStats")) {
+            module = "search";
+        }
+        else if (name.includes("session") || name.includes("Session") || name.includes("Constraint") || name.includes("Claim") || name.includes("Citation") || name.includes("Verification") || name.includes("Feasibility") || name.includes("Duplicate") || name.includes("Approval")) {
+            module = "session";
+        }
+        else if (name.includes("Stuck") || name.includes("Recovery")) {
+            module = "stuck";
+        }
+        else if (name.includes("Health") || name.includes("Circuit") || name.includes("RateLimit") || name.includes("Qdrant")) {
+            module = "health";
+        }
+        else if (name.includes("Research") || name.includes("Model")) {
+            module = "research";
+        }
+        else if (name.includes("memory_bank")) {
+            module = "memory-bank";
+        }
+        else if (name.includes("Relationship") || name.includes("Graph") || name.includes("link")) {
+            module = "graph";
+        }
+        else if (name.includes("consult") || name.includes("Consultation") || name.includes("Consensus") || name.includes("Review") || (name.includes("Decision") && name.includes("validate"))) {
+            module = "consultation";
+        }
+        else if (name.includes("Branch") || name.includes("branch") || (name.includes("Decision") && name.includes("Point"))) {
+            module = "branching";
+        }
+        else if (name.includes("rlvr")) {
+            module = "rlvr";
+        }
+        else if (name.includes("Learning") || name.includes("Knowledge") || name.includes("promote")) {
+            module = "knowledge";
+        }
+        else if (name.includes("trail")) {
+            module = "trails";
+        }
+        (modules[module] ??= []).push(tool);
+    }
+    const moduleOrder = [
+        "patterns",
+        "artifacts",
+        "memory",
+        "metrics",
+        "search",
+        "session",
+        "stuck",
+        "health",
+        "research",
+        "memory-bank",
+        "graph",
+        "consultation",
+        "branching",
+        "rlvr",
+        "knowledge",
+        "trails",
+        "other",
+    ];
+    for (const moduleName of moduleOrder) {
+        const moduleTools = modules[moduleName];
+        if (!moduleTools || moduleTools.length === 0)
+            continue;
+        console.log(`${moduleName.toUpperCase()} (${moduleTools.length} tools)`);
+        console.log("─".repeat(60));
+        for (const tool of moduleTools) {
+            const desc = tool.description?.split("\n")[0] || "";
+            const truncatedDesc = desc.length > 50 ? desc.slice(0, 47) + "..." : desc;
+            console.log(`  ${tool.name.padEnd(35)} ${truncatedDesc}`);
+        }
+        console.log("");
+    }
+}
+export async function printHealth() {
+    const version = getVersion();
+    console.log(`centient v${version} health check\n`);
+    const envVars = {
+        QDRANT_URL: process.env.QDRANT_URL,
+        QDRANT_API_KEY: process.env.QDRANT_API_KEY,
+        GEMINI_API_KEY: process.env.GEMINI_API_KEY,
+        OPENROUTER_API_KEY: process.env.OPENROUTER_API_KEY,
+    };
+    console.log("Environment:");
+    for (const [key, value] of Object.entries(envVars)) {
+        const status = value ? "\x1b[32m✓\x1b[0m configured" : "\x1b[31m✗\x1b[0m not set";
+        console.log(`  ${key.padEnd(20)} ${status}`);
+    }
+    console.log("\nServices:");
+    if (envVars.QDRANT_URL && envVars.QDRANT_API_KEY) {
+        try {
+            const response = await fetch(`${envVars.QDRANT_URL}/collections`, {
+                headers: {
+                    "api-key": envVars.QDRANT_API_KEY,
+                },
+                signal: AbortSignal.timeout(5000),
+            });
+            if (response.ok) {
+                console.log("  Qdrant Cloud          \x1b[32m✓\x1b[0m connected");
+            }
+            else {
+                console.log(`  Qdrant Cloud          \x1b[31m✗\x1b[0m error (${response.status})`);
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : "unknown error";
+            console.log(`  Qdrant Cloud          \x1b[31m✗\x1b[0m ${msg}`);
+        }
+    }
+    else {
+        console.log("  Qdrant Cloud          \x1b[33m-\x1b[0m not configured");
+    }
+    if (envVars.GEMINI_API_KEY) {
+        try {
+            const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${envVars.GEMINI_API_KEY}`, { signal: AbortSignal.timeout(5000) });
+            if (response.ok) {
+                console.log("  Gemini API            \x1b[32m✓\x1b[0m connected");
+            }
+            else {
+                console.log(`  Gemini API            \x1b[31m✗\x1b[0m error (${response.status})`);
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : "unknown error";
+            console.log(`  Gemini API            \x1b[31m✗\x1b[0m ${msg}`);
+        }
+    }
+    else {
+        console.log("  Gemini API            \x1b[33m-\x1b[0m not configured");
+    }
+    if (envVars.OPENROUTER_API_KEY) {
+        try {
+            const response = await fetch("https://openrouter.ai/api/v1/models", {
+                headers: {
+                    Authorization: `Bearer ${envVars.OPENROUTER_API_KEY}`,
+                },
+                signal: AbortSignal.timeout(5000),
+            });
+            if (response.ok) {
+                console.log("  OpenRouter API        \x1b[32m✓\x1b[0m connected");
+            }
+            else {
+                console.log(`  OpenRouter API        \x1b[31m✗\x1b[0m error (${response.status})`);
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : "unknown error";
+            console.log(`  OpenRouter API        \x1b[31m✗\x1b[0m ${msg}`);
+        }
+    }
+    else {
+        console.log("  OpenRouter API        \x1b[33m-\x1b[0m not configured");
+    }
+    console.log("");
+}
+export function printConfig() {
+    const version = getVersion();
+    console.log(`centient v${version} configuration\n`);
+    function redact(value) {
+        if (!value)
+            return "(not set)";
+        if (value.length <= 8)
+            return "***";
+        return value.slice(0, 4) + "..." + value.slice(-4);
+    }
+    console.log("Environment Variables:");
+    console.log(`  QDRANT_URL            ${process.env.QDRANT_URL || "(not set)"}`);
+    console.log(`  QDRANT_API_KEY        ${redact(process.env.QDRANT_API_KEY)}`);
+    console.log(`  GEMINI_API_KEY        ${redact(process.env.GEMINI_API_KEY)}`);
+    console.log(`  OPENROUTER_API_KEY    ${redact(process.env.OPENROUTER_API_KEY)}`);
+    console.log("\nPaths:");
+    console.log(`  Shared Patterns       ${getSharedPatternsPath()}`);
+    console.log(`  MCP Context           ${join(homedir(), ".mcp-context")}`);
+    console.log(`  Audit Log             ${getConfigAuditLogPath()}`);
+    const metaConfig = getMetaKnowledgeConfig();
+    console.log("\nMeta-Knowledge (Tier 3):");
+    console.log(`  Path                  ${metaConfig.path}`);
+    console.log(`  Encryption            ${metaConfig.encryption.enabled ? `✓ enabled (${metaConfig.encryption.keySource})` : "✗ disabled"}`);
+    console.log(`  Vertex Sync           ${metaConfig.vertex.enabled ? `✓ enabled (${metaConfig.vertex.projectId || "no project"})` : "✗ disabled"}`);
+    console.log(`  Retention             ${metaConfig.retention.days > 0 ? `${metaConfig.retention.days} days` : "∞ forever"}`);
+    if (metaConfig.retention.days > 0) {
+        console.log(`  Archive Path          ${metaConfig.retention.archivePath}`);
+    }
+    console.log("\nRuntime:");
+    console.log(`  Node.js               ${process.version}`);
+    console.log(`  Platform              ${process.platform} ${process.arch}`);
+    console.log(`  Working Directory     ${process.cwd()}`);
+    console.log("");
+}
+const isTTY = process.stdout.isTTY ?? false;
+const colors = isTTY ? {
+    reset: "\x1b[0m",
+    bright: "\x1b[1m",
+    dim: "\x1b[2m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    white: "\x1b[37m",
+    gray: "\x1b[90m",
+} : {
+    reset: "",
+    bright: "",
+    dim: "",
+    red: "",
+    green: "",
+    yellow: "",
+    blue: "",
+    magenta: "",
+    cyan: "",
+    white: "",
+    gray: "",
+};
+function formatLogEntry(entry) {
+    const time = new Date(entry.timestamp).toLocaleTimeString();
+    const outcomeColor = entry.outcome === "success" ? colors.green : colors.red;
+    const outcomeSymbol = entry.outcome === "success" ? "✓" : "✗";
+    const duration = `${entry.duration}ms`.padStart(6);
+    let summary = "";
+    if (entry.output) {
+        if ("resultCount" in entry.output) {
+            summary = `${entry.output.resultCount} results`;
+        }
+        else if ("errorMessage" in entry.output) {
+            const msg = String(entry.output.errorMessage);
+            summary = msg.length > 30 ? msg.slice(0, 27) + "..." : msg;
+        }
+        else if ("tokensUsed" in entry.output) {
+            summary = `${entry.output.tokensUsed} tokens`;
+        }
+    }
+    return `${colors.gray}${time}${colors.reset} │ ${colors.cyan}${entry.tool.padEnd(28)}${colors.reset} │ ${outcomeColor}${outcomeSymbol} ${duration}${colors.reset} │ ${summary}`;
+}
+function getAuditLogPath() {
+    return getConfigAuditLogPath();
+}
+async function readLastLines(filePath, n) {
+    if (!existsSync(filePath)) {
+        return [];
+    }
+    const entries = [];
+    const fileStream = createReadStream(filePath);
+    const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
+    for await (const line of rl) {
+        if (line.trim()) {
+            try {
+                entries.push(JSON.parse(line));
+            }
+            catch {
+            }
+        }
+    }
+    return entries.slice(-n);
+}
+export async function printStats() {
+    const version = getVersion();
+    console.log(`centient v${version} statistics\n`);
+    const logPath = getAuditLogPath();
+    if (!existsSync(logPath)) {
+        console.log(`${colors.yellow}No audit log found at ${logPath}${colors.reset}`);
+        console.log("Statistics will be available after centient processes some requests.\n");
+        return;
+    }
+    const stats = {
+        totalEvents: 0,
+        successCount: 0,
+        failureCount: 0,
+        totalDuration: 0,
+        toolCounts: {},
+        toolTotalDurations: {},
+        toolDurationCounts: {},
+        eventTypeCounts: {},
+        firstTimestamp: null,
+        lastTimestamp: null,
+    };
+    const fileStream = createReadStream(logPath);
+    const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
+    for await (const line of rl) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        stats.totalEvents++;
+        if (!stats.firstTimestamp) {
+            stats.firstTimestamp = entry.timestamp;
+        }
+        stats.lastTimestamp = entry.timestamp;
+        stats.toolCounts[entry.tool] = (stats.toolCounts[entry.tool] || 0) + 1;
+        stats.toolTotalDurations[entry.tool] = (stats.toolTotalDurations[entry.tool] || 0) + entry.duration;
+        stats.toolDurationCounts[entry.tool] = (stats.toolDurationCounts[entry.tool] || 0) + 1;
+        stats.eventTypeCounts[entry.eventType] = (stats.eventTypeCounts[entry.eventType] || 0) + 1;
+        if (entry.outcome === "success") {
+            stats.successCount++;
+        }
+        else {
+            stats.failureCount++;
+        }
+        stats.totalDuration += entry.duration;
+    }
+    if (stats.totalEvents === 0) {
+        console.log(`${colors.yellow}Audit log is empty${colors.reset}\n`);
+        return;
+    }
+    console.log(`${colors.bright}Summary${colors.reset}`);
+    console.log("─".repeat(50));
+    console.log(`  Total events:     ${stats.totalEvents}`);
+    console.log(`  Success rate:     ${colors.green}${((stats.successCount / stats.totalEvents) * 100).toFixed(1)}%${colors.reset} (${stats.successCount}/${stats.totalEvents})`);
+    console.log(`  Total duration:   ${(stats.totalDuration / 1000).toFixed(2)}s`);
+    console.log(`  Avg duration:     ${(stats.totalDuration / stats.totalEvents).toFixed(0)}ms`);
+    console.log("");
+    const sortedTools = Object.entries(stats.toolCounts)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10);
+    console.log(`${colors.bright}Top Tools${colors.reset}`);
+    console.log("─".repeat(50));
+    for (const [tool, count] of sortedTools) {
+        const totalDuration = stats.toolTotalDurations[tool] || 0;
+        const durationCount = stats.toolDurationCounts[tool] || 1;
+        const avgDuration = totalDuration / durationCount;
+        console.log(`  ${tool.padEnd(30)} ${String(count).padStart(5)} calls  ${avgDuration.toFixed(0).padStart(5)}ms avg`);
+    }
+    console.log("");
+    console.log(`${colors.bright}Event Types${colors.reset}`);
+    console.log("─".repeat(50));
+    for (const [eventType, count] of Object.entries(stats.eventTypeCounts).sort((a, b) => b[1] - a[1])) {
+        console.log(`  ${eventType.padEnd(30)} ${String(count).padStart(5)}`);
+    }
+    console.log("");
+    if (stats.firstTimestamp && stats.lastTimestamp) {
+        console.log(`${colors.bright}Time Range${colors.reset}`);
+        console.log("─".repeat(50));
+        console.log(`  From: ${new Date(stats.firstTimestamp).toLocaleString()}`);
+        console.log(`  To:   ${new Date(stats.lastTimestamp).toLocaleString()}`);
+    }
+    console.log("");
+}
+export async function log(options) {
+    const version = getVersion();
+    const logPath = getAuditLogPath();
+    console.log(`${colors.bright}AUDIT LOG${colors.reset}                                     v${version}`);
+    console.log("─".repeat(80));
+    console.log(`${colors.gray}Time${colors.reset}     │ ${colors.gray}Tool${colors.reset}                         │ ${colors.gray}Status${colors.reset}  │ ${colors.gray}Details${colors.reset}`);
+    console.log("─".repeat(80));
+    if (!existsSync(logPath)) {
+        console.log(`\n${colors.yellow}Waiting for audit log to be created...${colors.reset}`);
+        console.log(`Expected at: ${logPath}\n`);
+        if (!options.follow) {
+            return;
+        }
+        const dir = dirname(logPath);
+        if (existsSync(dir)) {
+            await new Promise((resolve) => {
+                const watcher = watch(dir, (_eventType, filename) => {
+                    if (filename === ".audit-log.jsonl" && existsSync(logPath)) {
+                        watcher.close();
+                        resolve();
+                    }
+                });
+            });
+        }
+    }
+    const entries = await readLastLines(logPath, options.last);
+    for (const entry of entries) {
+        console.log(formatLogEntry(entry));
+    }
+    if (!options.follow) {
+        console.log("─".repeat(80));
+        console.log(`${colors.gray}Showing last ${entries.length} events. Use --follow to watch in real-time.${colors.reset}`);
+        return;
+    }
+    console.log("─".repeat(80));
+    console.log(`${colors.gray}Watching for new events... (Ctrl+C to exit)${colors.reset}`);
+    console.log("─".repeat(80));
+    let lastSize = statSync(logPath).size;
+    const logWatcher = watch(logPath, async () => {
+        try {
+            if (!existsSync(logPath)) {
+                return;
+            }
+            const currentSize = statSync(logPath).size;
+            if (currentSize > lastSize) {
+                const stream = createReadStream(logPath, { start: lastSize });
+                const rl = createInterface({ input: stream, crlfDelay: Infinity });
+                for await (const line of rl) {
+                    if (line.trim()) {
+                        try {
+                            const entry = JSON.parse(line);
+                            console.log(formatLogEntry(entry));
+                        }
+                        catch {
+                        }
+                    }
+                }
+                lastSize = currentSize;
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                console.error(`${colors.red}Error reading log:${colors.reset}`, error);
+            }
+        }
+    });
+    const cleanup = () => {
+        logWatcher.close();
+        console.log(`\n${colors.gray}Monitor stopped.${colors.reset}`);
+        process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    await new Promise(() => {
+    });
+}
+function calculateReqPerMin(instance) {
+    if (instance.uptime === 0 || instance.requestCount === 0)
+        return 0;
+    const minutes = instance.uptime / 60;
+    if (minutes < 1)
+        return instance.requestCount;
+    return Math.round(instance.requestCount / minutes);
+}
+function getStatusIndicator(instance) {
+    if (isHeartbeatStale(instance)) {
+        return `${colors.yellow}?${colors.reset}`;
+    }
+    switch (instance.status) {
+        case "active":
+            return `${colors.green}●${colors.reset}`;
+        case "idle":
+            return `${colors.gray}○${colors.reset}`;
+        case "stopping":
+            return `${colors.red}-${colors.reset}`;
+        default:
+            return `${colors.blue}◐${colors.reset}`;
+    }
+}
+function formatInstanceRow(instance) {
+    const pid = String(instance.pid).padStart(5);
+    const project = instance.projectName.padEnd(24).slice(0, 24);
+    const tools = String(instance.toolCount).padStart(5);
+    const reqPerMin = String(calculateReqPerMin(instance)).padStart(5);
+    const mem = `${instance.memoryUsageMB}MB`.padStart(6);
+    const uptime = formatUptime(instance.uptime).padStart(7);
+    const status = getStatusIndicator(instance);
+    const statusText = instance.status.padEnd(7);
+    return ` ${pid}   ${project} ${tools}  ${reqPerMin}  ${mem}  ${uptime}   ${status} ${statusText}`;
+}
+function printInstanceTableHeader(version, instanceCount) {
+    const countText = instanceCount === 1 ? "1 instance" : `${instanceCount} instances`;
+    console.log(`${colors.bright}centient-monitor${colors.reset} v${version}                         ${countText}`);
+    console.log("─".repeat(80));
+    console.log(`${colors.gray}  PID   PROJECT                  TOOLS  REQ/M     MEM   UPTIME   STATUS${colors.reset}`);
+    console.log("─".repeat(80));
+}
+function printInstancesJson(instances) {
+    const stats = getAggregatedStats();
+    const output = {
+        timestamp: new Date().toISOString(),
+        instances: instances.map(i => ({
+            ...i,
+            reqPerMin: calculateReqPerMin(i),
+            stale: isHeartbeatStale(i),
+        })),
+        summary: stats,
+    };
+    console.log(JSON.stringify(output, null, 2));
+}
+function printInstancesQuiet(instances) {
+    for (const instance of instances) {
+        console.log(instance.pid);
+    }
+}
+function printInstancesSummary(version) {
+    const stats = getAggregatedStats();
+    const instances = listInstances();
+    console.log(`${colors.bright}centient-monitor${colors.reset} v${version}\n`);
+    const activeText = stats.activeInstances > 0
+        ? `${colors.green}${stats.activeInstances} active${colors.reset}`
+        : "0 active";
+    const idleText = stats.idleInstances > 0
+        ? `${colors.gray}${stats.idleInstances} idle${colors.reset}`
+        : "0 idle";
+    console.log(`Instances:     ${stats.totalInstances} total (${activeText}, ${idleText})`);
+    console.log(`Memory:        ${stats.totalMemoryMB} MB total`);
+    console.log(`Requests:      ${stats.totalRequests} total`);
+    if (instances.length > 0) {
+        const oldest = instances.reduce((a, b) => a.uptime > b.uptime ? a : b);
+        console.log(`Oldest:        ${formatUptime(oldest.uptime)} (${oldest.projectName})`);
+    }
+    console.log("");
+}
+function formatActivityEntry(projectName, entry) {
+    const time = new Date(entry.timestamp).toLocaleTimeString();
+    const outcomeColor = entry.outcome === "success" ? colors.green : colors.red;
+    const outcomeSymbol = entry.outcome === "success" ? "✓" : "✗";
+    const duration = `${entry.duration}ms`.padStart(6);
+    return ` ${colors.gray}${time}${colors.reset} │ ${colors.cyan}${projectName.padEnd(16).slice(0, 16)}${colors.reset} │ ${entry.tool.padEnd(24).slice(0, 24)} │ ${outcomeColor}${outcomeSymbol}${colors.reset} ${duration}`;
+}
+async function watchAllInstanceLogs(instances, onActivity) {
+    const watchers = [];
+    const fileSizes = new Map();
+    for (const instance of instances) {
+        const logPath = join(instance.projectPath, ".audit-log.jsonl");
+        if (!existsSync(logPath))
+            continue;
+        try {
+            fileSizes.set(logPath, statSync(logPath).size);
+            const watcher = watch(logPath, async () => {
+                try {
+                    if (!existsSync(logPath))
+                        return;
+                    const currentSize = statSync(logPath).size;
+                    const lastSize = fileSizes.get(logPath) || 0;
+                    if (currentSize > lastSize) {
+                        const stream = createReadStream(logPath, { start: lastSize });
+                        const rl = createInterface({ input: stream, crlfDelay: Infinity });
+                        for await (const line of rl) {
+                            if (line.trim()) {
+                                try {
+                                    const entry = JSON.parse(line);
+                                    onActivity(instance.projectName, entry);
+                                }
+                                catch {
+                                }
+                            }
+                        }
+                        fileSizes.set(logPath, currentSize);
+                    }
+                }
+                catch {
+                }
+            });
+            watchers.push(watcher);
+        }
+        catch {
+        }
+    }
+    return () => {
+        for (const watcher of watchers) {
+            watcher.close();
+        }
+    };
+}
+export async function monitor(options) {
+    const version = getVersion();
+    let instances = listInstances();
+    if (options.project) {
+        instances = instances.filter(i => i.projectName.toLowerCase().includes(options.project.toLowerCase()));
+    }
+    if (options.quiet) {
+        printInstancesQuiet(instances);
+        return;
+    }
+    if (options.json && !options.follow) {
+        printInstancesJson(instances);
+        return;
+    }
+    if (options.summary) {
+        printInstancesSummary(version);
+        return;
+    }
+    printInstanceTableHeader(version, instances.length);
+    if (instances.length === 0) {
+        console.log(`\n${colors.yellow}No running centient instances found.${colors.reset}`);
+        console.log(`${colors.gray}Start a centient MCP server to see it here.${colors.reset}\n`);
+        return;
+    }
+    for (const instance of instances) {
+        console.log(formatInstanceRow(instance));
+    }
+    console.log("─".repeat(80));
+    if (!options.follow) {
+        return;
+    }
+    console.log(`\n${colors.bright}Recent Activity${colors.reset}`);
+    console.log("─".repeat(80));
+    console.log(`${colors.gray}Watching for new events... (Ctrl+C to exit)${colors.reset}\n`);
+    const cleanup = await watchAllInstanceLogs(instances, (projectName, entry) => {
+        if (options.json) {
+            console.log(JSON.stringify({
+                type: "activity",
+                timestamp: entry.timestamp,
+                project: projectName,
+                tool: entry.tool,
+                duration: entry.duration,
+                outcome: entry.outcome,
+            }));
+        }
+        else {
+            console.log(formatActivityEntry(projectName, entry));
+        }
+    });
+    const shutdownHandler = () => {
+        cleanup();
+        console.log(`\n${colors.gray}Monitor stopped.${colors.reset}`);
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdownHandler);
+    process.on("SIGTERM", shutdownHandler);
+    await new Promise(() => {
+    });
+}
+export function parseArgs(args) {
+    let logLast = 20;
+    let logFollow = false;
+    let monitorFollow = false;
+    let monitorProject;
+    let monitorJson = false;
+    let monitorQuiet = false;
+    let monitorSummary = false;
+    let initForce = false;
+    let updateDryRun = false;
+    let hasMonitor = false;
+    let hasLog = false;
+    let hasInit = false;
+    let hasCheckCommands = false;
+    let hasUpdateCommands = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case "-V":
+            case "--version":
+                return { action: "version" };
+            case "-h":
+            case "--help":
+                return { action: "help" };
+            case "-l":
+            case "--list-tools":
+                return { action: "list-tools" };
+            case "--health":
+                return { action: "health" };
+            case "--config":
+                return { action: "config" };
+            case "--stats":
+                return { action: "stats" };
+            case "init":
+                hasInit = true;
+                break;
+            case "check-commands":
+                hasCheckCommands = true;
+                break;
+            case "update-commands":
+                hasUpdateCommands = true;
+                break;
+            case "--monitor":
+                hasMonitor = true;
+                break;
+            case "--log":
+                hasLog = true;
+                break;
+            case "-f":
+            case "--follow":
+                monitorFollow = true;
+                logFollow = true;
+                break;
+            case "-j":
+            case "--json":
+                monitorJson = true;
+                break;
+            case "-q":
+            case "--quiet":
+                monitorQuiet = true;
+                break;
+            case "-s":
+            case "--summary":
+                monitorSummary = true;
+                break;
+            case "--force":
+                initForce = true;
+                break;
+            case "--dry-run":
+                updateDryRun = true;
+                break;
+            case "-p":
+            case "--project":
+                const projectArg = args[i + 1];
+                if (projectArg && !projectArg.startsWith("-")) {
+                    monitorProject = projectArg;
+                    i++;
+                }
+                break;
+            case "--last":
+                const lastArg = args[i + 1];
+                if (lastArg && !lastArg.startsWith("-")) {
+                    logLast = parseInt(lastArg, 10) || 20;
+                    i++;
+                }
+                break;
+            default:
+                if (arg && arg.startsWith("-")) {
+                    console.error(`Warning: Unknown option '${arg}'`);
+                }
+                break;
+        }
+    }
+    if (hasLog) {
+        return { action: "log", logOptions: { last: logLast, follow: logFollow } };
+    }
+    if (hasMonitor) {
+        return {
+            action: "monitor",
+            monitorOptions: {
+                follow: monitorFollow,
+                project: monitorProject,
+                json: monitorJson,
+                quiet: monitorQuiet,
+                summary: monitorSummary,
+            },
+        };
+    }
+    if (hasInit) {
+        return { action: "init", initOptions: { force: initForce } };
+    }
+    if (hasCheckCommands) {
+        return { action: "check-commands" };
+    }
+    if (hasUpdateCommands) {
+        return { action: "update-commands", updateOptions: { force: initForce, dryRun: updateDryRun } };
+    }
+    return { action: "server" };
+}
+//# sourceMappingURL=cli.js.map