jobarbiter 0.3.13 → 0.4.1

package/src/index.ts

@@ -6,8 +6,13 @@ import { api, apiUnauthenticated, ApiError } from "./lib/api.js";
 import { output, outputList, success, error, setJsonMode } from "./lib/output.js";
 import { runOnboardWizard } from "./lib/onboard.js";
 import { detectAgents, installObservers, removeObservers, getObservationStatus } from "./lib/observe.js";
-import { getObservableTools, formatToolDisplay } from "./lib/detect-tools.js";
+import { getObservableTools, formatToolDisplay, detectAllTools } from "./lib/detect-tools.js";
 import { runAutoPipeline, analyzeFile, analyzeRecent } from "./lib/analysis-pipeline.js";
+import { pollAllSources } from "./lib/transcript-poller.js";
+import { pauseObservation, resumeObservation, isPaused, getPauseStatus } from "./lib/privacy-pause.js";
+import { loadPollState, savePollState, setDisabledSource, removeDisabledSource } from "./lib/poll-state.js";
+import { installDaemon, uninstallDaemon, getDaemonStatus, reloadDaemon } from "./lib/launchd.js";
+import { uninstallAll } from "./lib/uninstall.js";
 
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
@@ -801,16 +806,42 @@ const observe = program.command("observe").description("Manage AI tool proficien
 
 observe
 	.command("status")
-	.description("Show observer status and accumulated data")
+	.description("Show observer status, pause state, daemon, and accumulated data")
 	.action(async () => {
 		try {
 			const agents = detectAgents();
 			const status = getObservationStatus();
-
-			const detected = agents.filter((a) => a.installed);
+			const pauseStatus = getPauseStatus();
+			const daemonStatus = getDaemonStatus();
+			const pollState = loadPollState();
 
 			console.log("\n🔍 AI Agent Observers\n");
-			console.log("  Agents:");
+
+			// Pause state
+			if (pauseStatus.paused) {
+				console.log(`  ⏸️  Status: ${pauseStatus.expiresAt
+					? `PAUSED (auto-resumes ${new Date(pauseStatus.expiresAt).toLocaleString()})`
+					: "PAUSED (indefinite)"}`);
+				console.log(`     Since: ${pauseStatus.pausedAt ? new Date(pauseStatus.pausedAt).toLocaleString() : "unknown"}`);
+			} else {
+				console.log("  ▶️  Status: ACTIVE");
+			}
+
+			// Daemon state
+			console.log(`\n  Poller Daemon:`);
+			if (daemonStatus.installed) {
+				console.log(`    ${daemonStatus.loaded ? "✅" : "⚠️"}  ${daemonStatus.loaded ? "Running" : "Installed but not loaded"}`);
+				if (daemonStatus.interval) {
+					const hours = Math.floor(daemonStatus.interval / 3600);
+					const mins = Math.floor((daemonStatus.interval % 3600) / 60);
+					console.log(`    Interval: ${hours > 0 ? `${hours}h` : ""}${mins > 0 ? `${mins}m` : ""}`);
+				}
+			} else {
+				console.log("    ⬚ Not installed (run: jobarbiter observe daemon install)");
+			}
+
+			// Agents
+			console.log("\n  Agents:");
 			for (const agent of agents) {
 				if (!agent.installed) {
 					console.log(`    ⬚ ${agent.name}  (not installed)`);
@@ -821,6 +852,20 @@ observe
 				}
 			}
 
+			// Per-source poll stats
+			const pollEntries = Object.entries(pollState.lastPoll);
+			if (pollEntries.length > 0) {
+				console.log("\n  Last Poll Per Source:");
+				for (const [source, time] of pollEntries) {
+					console.log(`    ${source}: ${new Date(time).toLocaleString()}`);
+				}
+			}
+
+			// Disabled sources
+			if (pollState.disabledSources.length > 0) {
+				console.log(`\n  Disabled Sources: ${pollState.disabledSources.join(", ")}`);
+			}
+
 			console.log("\n  Accumulated Data:");
 			console.log(`    Sessions observed: ${status.totalSessions}`);
 			console.log(`    Total tokens:      ${status.totalTokens.toLocaleString()}`);
@@ -834,9 +879,25 @@ observe
 				}
 			}
 
+			// Pause history (last 5)
+			if (pauseStatus.pauseWindows.length > 0) {
+				console.log("\n  Pause History (last 5):");
+				const recent = pauseStatus.pauseWindows.slice(-5);
+				for (const w of recent) {
+					const start = new Date(w.start).toLocaleString();
+					const end = new Date(w.end).toLocaleString();
+					console.log(`    ${start} → ${end}`);
+				}
+			}
+
 			console.log(`\n  Data file: ~/.config/jobarbiter/observer/observations.json\n`);
 
 			output({
+				paused: pauseStatus.paused,
+				pausedAt: pauseStatus.pausedAt,
+				expiresAt: pauseStatus.expiresAt,
+				daemon: daemonStatus,
+				disabledSources: pollState.disabledSources,
 				detectedAgents: agents.map((a) => ({
 					id: a.id,
 					name: a.name,
@@ -844,6 +905,7 @@ observe
 					observerActive: a.hookInstalled,
 				})),
 				...status,
+				pauseWindows: pauseStatus.pauseWindows,
 			});
 		} catch (e) {
 			handleError(e);
@@ -974,6 +1036,286 @@ observe
 		}
 	});
 
+// ── observe poll ────────────────────────────────────────────────────────
+
+observe
+	.command("poll")
+	.description("One-shot poll for new transcripts from all sources")
+	.option("--source <id>", "Poll a specific source only")
+	.option("--dry-run", "Show what would be processed without writing")
+	.option("--since <date>", "Only process transcripts since this date (ISO 8601)")
+	.option("--verbose", "Show detailed output")
+	.action(async (opts) => {
+		try {
+			const since = opts.since ? new Date(opts.since) : undefined;
+			const result = await pollAllSources({
+				source: opts.source,
+				dryRun: opts.dryRun,
+				since,
+				verbose: opts.verbose,
+			});
+
+			if (!opts.verbose) {
+				if (result.newSessions > 0) {
+					success(`Found ${result.newSessions} new session(s) from ${result.sourcesPolled.length} source(s)`);
+				} else {
+					console.log(`No new sessions found (polled ${result.sourcesPolled.length} sources)`);
+				}
+				if (result.skippedDuplicate > 0) {
+					console.log(`  Skipped ${result.skippedDuplicate} duplicate(s)`);
+				}
+				if (result.skippedPaused > 0) {
+					console.log(`  Skipped ${result.skippedPaused} from pause window(s)`);
+				}
+			}
+
+			if (result.errors.length > 0) {
+				for (const e of result.errors) {
+					console.log(`  ⚠️  ${e}`);
+				}
+			}
+
+			output(result as unknown as Record<string, unknown>);
+		} catch (e) {
+			handleError(e);
+		}
+	});
+
+// ── observe pause/resume ───────────────────────────────────────────────
+
+observe
+	.command("pause")
+	.description("Pause all observation (hooks + poller)")
+	.option("--for <duration>", "Auto-resume after duration (e.g. 2h, 30m, 1d)")
+	.action(async (opts) => {
+		try {
+			let expiresAt: Date | undefined;
+			if (opts.for) {
+				const seconds = parseDuration(opts.for);
+				if (seconds <= 0) {
+					error("Invalid duration. Use format like '2h', '30m', '1d'");
+					process.exit(1);
+				}
+				expiresAt = new Date(Date.now() + seconds * 1000);
+			}
+
+			pauseObservation(expiresAt);
+
+			if (expiresAt) {
+				success(`Observation paused until ${expiresAt.toLocaleString()}`);
+			} else {
+				success("Observation paused indefinitely. Run 'jobarbiter observe resume' to resume.");
+			}
+
+			output({ paused: true, expiresAt: expiresAt?.toISOString() || null });
+		} catch (e) {
+			handleError(e);
+		}
+	});
+
+observe
+	.command("resume")
+	.description("Resume observation after a pause")
+	.action(async () => {
+		try {
+			if (!isPaused()) {
+				console.log("Observation is not paused.");
+				output({ resumed: false, reason: "not_paused" });
+				process.exit(0);
+			}
+
+			resumeObservation();
+			success("Observation resumed. Pause window recorded.");
+			output({ resumed: true });
+		} catch (e) {
+			handleError(e);
+		}
+	});
+
+// ── observe interval ───────────────────────────────────────────────────
+
+observe
+	.command("interval <duration>")
+	.description("Change poll frequency (e.g. 2h, 30m, 1d)")
+	.action(async (duration) => {
+		try {
+			const seconds = parseDuration(duration);
+			if (seconds <= 0) {
+				error("Invalid duration. Use format like '2h', '30m', '1d'");
+				process.exit(1);
+			}
+
+			const state = loadPollState();
+			state.interval = seconds;
+			savePollState(state);
+
+			// Reload daemon if installed
+			const daemonStatus = getDaemonStatus();
+			if (daemonStatus.installed) {
+				installDaemon(seconds);
+				success(`Poll interval set to ${duration} and daemon reloaded`);
+			} else {
+				success(`Poll interval set to ${duration}`);
+			}
+
+			output({ interval: seconds });
+		} catch (e) {
+			handleError(e);
+		}
+	});
+
+// ── observe enable/disable ─────────────────────────────────────────────
+
+observe
+	.command("enable <source>")
+	.description("Re-enable a disabled observation source")
+	.action(async (source) => {
+		try {
+			removeDisabledSource(source);
+			success(`Source '${source}' enabled`);
+			output({ source, enabled: true });
+		} catch (e) {
+			handleError(e);
+		}
+	});
+
+observe
+	.command("disable <source>")
+	.description("Disable observation for a specific source")
+	.action(async (source) => {
+		try {
+			setDisabledSource(source);
+			success(`Source '${source}' disabled`);
+			output({ source, disabled: true });
+		} catch (e) {
+			handleError(e);
+		}
+	});
+
+// ── observe daemon ─────────────────────────────────────────────────────
+
+const daemon = observe.command("daemon").description("Manage the background polling daemon (macOS LaunchAgent)");
+
+daemon
+	.command("install")
+	.description("Install the background polling daemon")
+	.option("--interval <duration>", "Poll interval (e.g. 2h, 30m)", "2h")
+	.action(async (opts) => {
+		try {
+			const seconds = parseDuration(opts.interval);
+			if (seconds <= 0) {
+				error("Invalid interval. Use format like '2h', '30m', '1d'");
+				process.exit(1);
+			}
+
+			installDaemon(seconds);
+			success(`Polling daemon installed (interval: ${opts.interval})`);
+			console.log("  The daemon will poll for new transcripts in the background.");
+			console.log("  Log: ~/.config/jobarbiter/observer/poll.log");
+			output({ installed: true, interval: seconds });
+		} catch (e) {
+			handleError(e);
+		}
+	});
+
+daemon
+	.command("uninstall")
+	.description("Remove the background polling daemon")
+	.action(async () => {
+		try {
+			uninstallDaemon();
+			success("Polling daemon uninstalled");
+			output({ uninstalled: true });
+		} catch (e) {
+			handleError(e);
+		}
+	});
+
+daemon
+	.command("status")
+	.description("Show daemon status")
+	.action(async () => {
+		try {
+			const status = getDaemonStatus();
+
+			if (!status.installed) {
+				console.log("\nDaemon not installed. Run: jobarbiter observe daemon install\n");
+			} else {
+				console.log(`\nDaemon: ${status.loaded ? "✅ Running" : "⚠️  Installed but not loaded"}`);
+				if (status.interval) {
+					const hours = Math.floor(status.interval / 3600);
+					const mins = Math.floor((status.interval % 3600) / 60);
+					console.log(`Interval: ${hours > 0 ? `${hours}h` : ""}${mins > 0 ? `${mins}m` : ""}`);
+				}
+				console.log(`Plist: ${status.plistPath}\n`);
+			}
+
+			output(status as unknown as Record<string, unknown>);
+		} catch (e) {
+			handleError(e);
+		}
+	});
+
+// ============================================================
+// uninstall (clean removal)
+// ============================================================
+
+program
+	.command("uninstall")
+	.description("Remove all JobArbiter components from this system")
+	.option("--keep-data", "Keep observation data")
+	.option("--keep-config", "Keep configuration files")
+	.option("--force", "Skip confirmation prompts")
+	.action(async (opts) => {
+		try {
+			if (!opts.force) {
+				console.log("\n⚠️  This will remove:");
+				console.log("  - Observer hooks from all AI tools");
+				console.log("  - Background polling daemon");
+				console.log("  - Hook scripts");
+				if (!opts.keepData) console.log("  - Observation data");
+				if (!opts.keepConfig) console.log("  - Configuration and API keys");
+				console.log();
+
+				const readline = await import("node:readline");
+				const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+				const answer = await new Promise<string>((resolve) => {
+					rl.question("Continue? [y/N] ", (ans) => { rl.close(); resolve(ans); });
+				});
+				if (!answer.toLowerCase().startsWith("y")) {
+					console.log("Cancelled.");
+					process.exit(0);
+				}
+			}
+
+			const result = uninstallAll({
+				keepData: opts.keepData,
+				keepConfig: opts.keepConfig,
+				force: opts.force,
+			});
+
+			if (result.observersRemoved.length > 0) {
+				success(`Removed observers: ${result.observersRemoved.join(", ")}`);
+			}
+			if (result.daemonUninstalled) success("Daemon uninstalled");
+			if (result.hooksDeleted) success("Hook scripts deleted");
+			if (result.dataDeleted) success("Observation data deleted");
+			if (result.configDeleted) success("Configuration deleted");
+
+			for (const e of result.errors) {
+				error(e);
+			}
+
+			if (result.errors.length === 0) {
+				console.log("\n✅ JobArbiter fully uninstalled.\n");
+			}
+
+			output(result as unknown as Record<string, unknown>);
+		} catch (e) {
+			handleError(e);
+		}
+	});
+
 // ============================================================
 // analyze (session analysis and report submission)
 // ============================================================
@@ -1078,6 +1420,7 @@ program
 	.command("update")
 	.description("Check for and install CLI updates")
 	.option("--check", "Just check for updates, don't install")
+	.option("--no-reinstall-observers", "Skip automatic observer reinstall on major/minor bump")
 	.action(async (opts) => {
 		try {
 			console.log(`\nCurrent version: v${CLI_VERSION}`);
@@ -1129,9 +1472,31 @@ program
 				pa[0] !== pb[0] || pa[1] !== pb[1];
 
 			if (majorMinorChanged) {
-				console.log("\n⚠️  Major/minor version changed. You may want to reinstall observers:");
-				console.log("   jobarbiter observe remove --all");
-				console.log("   jobarbiter observe install --all\n");
+				if (opts.reinstallObservers) {
+					console.log("\nReinstalling observers for new version...");
+					try {
+						const agents = await detectAgents();
+						const installedIds = agents.filter(a => a.installed).map(a => a.id);
+						if (installedIds.length === 0) {
+							console.log("  No observers installed — nothing to reinstall.\n");
+						} else {
+							await removeObservers(installedIds);
+							console.log(`  ✔ Removed observers for: ${installedIds.join(", ")}`);
+							await installObservers(installedIds);
+							success(`Reinstalled observers for: ${installedIds.join(", ")}`);
+						}
+					} catch (reinstallErr) {
+						error(`Failed to reinstall observers: ${reinstallErr instanceof Error ? reinstallErr.message : String(reinstallErr)}`);
+						console.log("  You can manually reinstall with:");
+						console.log("   jobarbiter observe remove --all");
+						console.log("   jobarbiter observe install --all\n");
+					}
+				} else {
+					console.log("\n⚠️  Major/minor version changed. Skipped observer reinstall (--no-reinstall-observers).");
+					console.log("   To reinstall manually:");
+					console.log("   jobarbiter observe remove --all");
+					console.log("   jobarbiter observe install --all\n");
+				}
 			}
 		} catch (e) {
 			handleError(e);
@@ -1161,6 +1526,28 @@ function handleError(e: unknown): void {
 	process.exit(1);
 }
 
+/**
+ * Parse duration strings like '2h', '30m', '1d' into seconds.
+ */
+function parseDuration(input: string): number {
+	const match = input.match(/^(\d+(?:\.\d+)?)\s*(s|m|h|d|w)$/i);
+	if (!match) {
+		// Try bare number as seconds
+		const n = parseFloat(input);
+		return isNaN(n) ? 0 : n;
+	}
+	const value = parseFloat(match[1]);
+	const unit = match[2].toLowerCase();
+	switch (unit) {
+		case "s": return value;
+		case "m": return value * 60;
+		case "h": return value * 3600;
+		case "d": return value * 86400;
+		case "w": return value * 604800;
+		default: return 0;
+	}
+}
+
 function formatCompensation(comp: Record<string, unknown> | undefined): string {
 	if (!comp) return "Not listed";
 	const min = comp.min as number;