jobarbiter 0.3.12 → 0.4.0

package/dist/lib/privacy-pause.js

@@ -0,0 +1,137 @@
+/**
+ * Privacy Pause Management
+ *
+ * Manages the PAUSED sentinel file at ~/.config/jobarbiter/observer/PAUSED
+ * When paused, all observation hooks and pollers exit immediately.
+ */
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { addPauseWindow, loadPollState } from "./poll-state.js";
+// ── Paths ──────────────────────────────────────────────────────────────
+const OBSERVER_DIR = join(homedir(), ".config", "jobarbiter", "observer");
+const PAUSED_FILE = join(OBSERVER_DIR, "PAUSED");
+const OBSERVATIONS_FILE = join(OBSERVER_DIR, "observations.json");
+// ── Functions ──────────────────────────────────────────────────────────
+export function pauseObservation(expiresAt) {
+    mkdirSync(OBSERVER_DIR, { recursive: true });
+    const data = {
+        pausedAt: new Date().toISOString(),
+        expiresAt: expiresAt ? expiresAt.toISOString() : null,
+    };
+    writeFileSync(PAUSED_FILE, JSON.stringify(data, null, 2) + "\n");
+}
+export function resumeObservation() {
+    if (!existsSync(PAUSED_FILE))
+        return;
+    // Read pause data to record pause window
+    try {
+        const raw = readFileSync(PAUSED_FILE, "utf-8");
+        const data = JSON.parse(raw);
+        const now = new Date().toISOString();
+        addPauseWindow(data.pausedAt, now);
+    }
+    catch {
+        // Best effort
+    }
+    // Remove PAUSED file
+    try {
+        unlinkSync(PAUSED_FILE);
+    }
+    catch {
+        // Already removed
+    }
+    // Sweep observations.json for entries that leaked during pause
+    sweepLeakedObservations();
+}
+export function isPaused() {
+    if (!existsSync(PAUSED_FILE))
+        return false;
+    try {
+        const raw = readFileSync(PAUSED_FILE, "utf-8");
+        const data = JSON.parse(raw);
+        // Check if expired
+        if (data.expiresAt) {
+            const expiresAt = new Date(data.expiresAt).getTime();
+            if (Date.now() >= expiresAt) {
+                // Auto-resume: expired
+                autoResume(data);
+                return false;
+            }
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function getPauseStatus() {
+    const state = loadPollState();
+    const result = {
+        paused: false,
+        pausedAt: null,
+        expiresAt: null,
+        pauseWindows: state.pauseWindows,
+    };
+    if (!existsSync(PAUSED_FILE))
+        return result;
+    try {
+        const raw = readFileSync(PAUSED_FILE, "utf-8");
+        const data = JSON.parse(raw);
+        // Check for expiry
+        if (data.expiresAt) {
+            const expiresAt = new Date(data.expiresAt).getTime();
+            if (Date.now() >= expiresAt) {
+                autoResume(data);
+                return result;
+            }
+        }
+        result.paused = true;
+        result.pausedAt = data.pausedAt;
+        result.expiresAt = data.expiresAt;
+    }
+    catch {
+        // Corrupted PAUSED file
+    }
+    return result;
+}
+// ── Internal Helpers ───────────────────────────────────────────────────
+function autoResume(data) {
+    const now = new Date().toISOString();
+    addPauseWindow(data.pausedAt, data.expiresAt || now);
+    try {
+        unlinkSync(PAUSED_FILE);
+    }
+    catch {
+        // Already removed
+    }
+    sweepLeakedObservations();
+}
+function sweepLeakedObservations() {
+    if (!existsSync(OBSERVATIONS_FILE))
+        return;
+    try {
+        const raw = readFileSync(OBSERVATIONS_FILE, "utf-8");
+        const data = JSON.parse(raw);
+        if (!Array.isArray(data.sessions))
+            return;
+        const state = loadPollState();
+        const originalCount = data.sessions.length;
+        data.sessions = data.sessions.filter((session) => {
+            if (!session.timestamp)
+                return true;
+            const ts = new Date(session.timestamp).getTime();
+            return !state.pauseWindows.some((w) => {
+                const start = new Date(w.start).getTime();
+                const end = new Date(w.end).getTime();
+                return ts >= start && ts <= end;
+            });
+        });
+        if (data.sessions.length !== originalCount) {
+            writeFileSync(OBSERVATIONS_FILE, JSON.stringify(data, null, 2) + "\n");
+        }
+    }
+    catch {
+        // Best effort
+    }
+}

package/dist/lib/transcript-poller.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Transcript Poller
+ *
+ * Core polling logic that discovers and processes new transcripts
+ * from AI tools that don't support hooks (aider, goose, letta, etc.).
+ * Uses existing discoverTranscripts() and parseTranscriptFile() from
+ * transcript-reader.ts.
+ */
+export interface PollResult {
+    sourcesPolled: string[];
+    newSessions: number;
+    skippedPaused: number;
+    skippedDuplicate: number;
+    errors: string[];
+}
+interface PollOptions {
+    dryRun?: boolean;
+    source?: string;
+    verbose?: boolean;
+    since?: Date;
+}
+export declare function pollAllSources(options?: PollOptions): Promise<PollResult>;
+export {};

package/dist/lib/transcript-poller.js

@@ -0,0 +1,218 @@
+/**
+ * Transcript Poller
+ *
+ * Core polling logic that discovers and processes new transcripts
+ * from AI tools that don't support hooks (aider, goose, letta, etc.).
+ * Uses existing discoverTranscripts() and parseTranscriptFile() from
+ * transcript-reader.ts.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { discoverTranscripts, parseTranscriptFile } from "./transcript-reader.js";
+import { detectAllTools } from "./detect-tools.js";
+import { isPaused } from "./privacy-pause.js";
+import { loadPollState, savePollState, addKnownSession, isKnownSession, isInPauseWindow, } from "./poll-state.js";
+import { analyzeSession } from "./session-analyzer.js";
+// ── Paths ──────────────────────────────────────────────────────────────
+const OBSERVER_DIR = join(homedir(), ".config", "jobarbiter", "observer");
+const OBSERVATIONS_FILE = join(OBSERVER_DIR, "observations.json");
+// ── Source-to-tool mapping ─────────────────────────────────────────────
+const POLLER_SOURCES = [
+    "aider", "goose", "letta", "zed", "amazon-q",
+    "claude-code", "cursor", "codex", "gemini", "opencode",
+    "continue", "cline", "copilot-chat", "windsurf", "openclaw", "warp", "idx",
+];
+// ── Main Entry Point ───────────────────────────────────────────────────
+export async function pollAllSources(options) {
+    const result = {
+        sourcesPolled: [],
+        newSessions: 0,
+        skippedPaused: 0,
+        skippedDuplicate: 0,
+        errors: [],
+    };
+    // Check pause state first
+    if (isPaused()) {
+        if (options?.verbose) {
+            result.errors.push("Observation is paused — skipping poll");
+        }
+        return result;
+    }
+    const state = loadPollState();
+    // Determine which sources to poll
+    let sourcesToPoll;
+    if (options?.source) {
+        if (!POLLER_SOURCES.includes(options.source)) {
+            result.errors.push(`Unknown source: ${options.source}`);
+            return result;
+        }
+        sourcesToPoll = [options.source];
+    }
+    else {
+        // Filter to installed + not disabled
+        const allTools = detectAllTools();
+        const installedToolIds = new Set(allTools.filter((t) => t.installed).map((t) => t.id));
+        const disabledSet = new Set(state.disabledSources);
+        sourcesToPoll = POLLER_SOURCES.filter((source) => {
+            // Map source names to tool IDs (most are the same)
+            const toolId = sourceToToolId(source);
+            return installedToolIds.has(toolId) && !disabledSet.has(source);
+        });
+    }
+    if (sourcesToPoll.length === 0) {
+        if (options?.verbose) {
+            result.errors.push("No sources to poll (none installed or all disabled)");
+        }
+        return result;
+    }
+    // Discover all transcripts, then filter to sources we want
+    const oldestSince = sourcesToPoll.reduce((oldest, source) => {
+        const sourceDate = options?.since || (state.lastPoll[source]
+            ? new Date(state.lastPoll[source])
+            : new Date(Date.now() - 7 * 24 * 60 * 60 * 1000));
+        return sourceDate < oldest ? sourceDate : oldest;
+    }, new Date());
+    const allDiscovered = discoverTranscripts({
+        since: oldestSince,
+        maxFiles: 50,
+    });
+    const sourcesToPollSet = new Set(sourcesToPoll);
+    for (const entry of allDiscovered) {
+        const source = entry.source;
+        if (!sourcesToPollSet.has(source))
+            continue;
+        result.sourcesPolled.push(source);
+        for (const file of entry.files) {
+            try {
+                const transcript = parseTranscriptFile(file, source);
+                if (!transcript || transcript.messages.length < 3)
+                    continue;
+                const sessionId = transcript.sessionId;
+                // Dedup check
+                if (isKnownSession(sessionId)) {
+                    result.skippedDuplicate++;
+                    continue;
+                }
+                // Pause window check
+                if (transcript.startTime && isInPauseWindow(transcript.startTime)) {
+                    result.skippedPaused++;
+                    continue;
+                }
+                if (options?.dryRun) {
+                    result.newSessions++;
+                    if (options.verbose) {
+                        console.log(`  [dry-run] Would process: ${source}/${sessionId} (${transcript.messages.length} messages)`);
+                    }
+                    continue;
+                }
+                // Analyze and extract signals
+                const report = analyzeSession(transcript);
+                const observation = {
+                    timestamp: new Date().toISOString(),
+                    agent: source,
+                    sessionId,
+                    source: "poller",
+                    signals: {
+                        toolsUsed: report.qualitativeAssessment.toolFluency.toolsUsed,
+                        fileExtensions: report.qualitativeAssessment.domainExpertise.domains,
+                        messageCount: report.quantitativeMetrics.messageCount,
+                        thinkingBlocks: report.quantitativeMetrics.thinkingBlocks,
+                        tokenUsage: report.quantitativeMetrics.tokenCount > 0
+                            ? { total: report.quantitativeMetrics.tokenCount }
+                            : null,
+                        duration: report.quantitativeMetrics.sessionDurationMinutes > 0
+                            ? report.quantitativeMetrics.sessionDurationMinutes
+                            : null,
+                    },
+                };
+                appendObservation(observation);
+                addKnownSession(sessionId);
+                result.newSessions++;
+                if (options?.verbose) {
+                    console.log(`  Processed: ${source}/${sessionId} (${transcript.messages.length} messages)`);
+                }
+            }
+            catch (err) {
+                result.errors.push(`${source}/${file}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        // Update last poll time for this source
+        state.lastPoll[source] = new Date().toISOString();
+    }
+    // Save updated poll state
+    savePollState(state);
+    return result;
+}
+// ── Helpers ────────────────────────────────────────────────────────────
+function sourceToToolId(source) {
+    const mapping = {
+        "zed": "zed-ai",
+        "amazon-q": "amazon-q",
+        "copilot-chat": "copilot-chat",
+        "warp": "warp-ai",
+    };
+    return mapping[source] || source;
+}
+function appendObservation(obs) {
+    mkdirSync(OBSERVER_DIR, { recursive: true });
+    try {
+        let data;
+        if (existsSync(OBSERVATIONS_FILE)) {
+            data = JSON.parse(readFileSync(OBSERVATIONS_FILE, "utf-8"));
+        }
+        else {
+            data = {
+                version: 1,
+                installedAt: new Date().toISOString(),
+                agents: {},
+                sessions: [],
+                accumulated: {
+                    totalSessions: 0,
+                    totalTokens: 0,
+                    toolCounts: {},
+                    domainSignals: [],
+                    lastSubmitted: null,
+                },
+            };
+        }
+        const sessions = data.sessions;
+        sessions.push(obs);
+        const accumulated = data.accumulated;
+        accumulated.totalSessions = (accumulated.totalSessions || 0) + 1;
+        // Update tool counts
+        const signals = obs.signals;
+        const toolsUsed = (signals.toolsUsed || []);
+        const toolCounts = accumulated.toolCounts;
+        for (const tool of toolsUsed) {
+            toolCounts[tool] = (toolCounts[tool] || 0) + 1;
+        }
+        // Update token totals
+        const tokenUsage = signals.tokenUsage;
+        if (tokenUsage?.total) {
+            accumulated.totalTokens = (accumulated.totalTokens || 0) + tokenUsage.total;
+        }
+        // Rolling window of 500 sessions
+        if (sessions.length > 500) {
+            data.sessions = sessions.slice(-500);
+        }
+        writeFileSync(OBSERVATIONS_FILE, JSON.stringify(data, null, 2) + "\n");
+    }
+    catch {
+        // If file is corrupted, start fresh
+        const freshData = {
+            version: 1,
+            installedAt: new Date().toISOString(),
+            agents: {},
+            sessions: [obs],
+            accumulated: {
+                totalSessions: 1,
+                totalTokens: 0,
+                toolCounts: {},
+                domainSignals: [],
+                lastSubmitted: null,
+            },
+        };
+        writeFileSync(OBSERVATIONS_FILE, JSON.stringify(freshData, null, 2) + "\n");
+    }
+}

package/dist/lib/uninstall.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Uninstall Module
+ *
+ * Clean removal of all JobArbiter components:
+ * observers, daemon, hooks, and optionally data/config.
+ */
+export interface UninstallOptions {
+    keepData?: boolean;
+    keepConfig?: boolean;
+    force?: boolean;
+}
+export interface UninstallResult {
+    observersRemoved: string[];
+    daemonUninstalled: boolean;
+    hooksDeleted: boolean;
+    dataDeleted: boolean;
+    configDeleted: boolean;
+    errors: string[];
+}
+export declare function uninstallAll(options?: UninstallOptions): UninstallResult;

package/dist/lib/uninstall.js

@@ -0,0 +1,81 @@
+/**
+ * Uninstall Module
+ *
+ * Clean removal of all JobArbiter components:
+ * observers, daemon, hooks, and optionally data/config.
+ */
+import { existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { detectAgents, removeObservers } from "./observe.js";
+import { uninstallDaemon } from "./launchd.js";
+// ── Paths ──────────────────────────────────────────────────────────────
+const CONFIG_DIR = join(homedir(), ".config", "jobarbiter");
+const OBSERVER_DIR = join(CONFIG_DIR, "observer");
+const HOOKS_DIR = join(OBSERVER_DIR, "hooks");
+// ── Main Function ──────────────────────────────────────────────────────
+export function uninstallAll(options = {}) {
+    const result = {
+        observersRemoved: [],
+        daemonUninstalled: false,
+        hooksDeleted: false,
+        dataDeleted: false,
+        configDeleted: false,
+        errors: [],
+    };
+    // 1. Remove observers from all agents
+    try {
+        const agents = detectAgents();
+        const withHooks = agents.filter((a) => a.hookInstalled);
+        if (withHooks.length > 0) {
+            const removeResult = removeObservers(withHooks.map((a) => a.id));
+            result.observersRemoved = removeResult.removed;
+        }
+    }
+    catch (err) {
+        result.errors.push(`Failed to remove observers: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // 2. Uninstall launchd daemon
+    try {
+        uninstallDaemon();
+        result.daemonUninstalled = true;
+    }
+    catch (err) {
+        result.errors.push(`Failed to uninstall daemon: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // 3. Delete observer hooks directory
+    try {
+        if (existsSync(HOOKS_DIR)) {
+            rmSync(HOOKS_DIR, { recursive: true, force: true });
+            result.hooksDeleted = true;
+        }
+    }
+    catch (err) {
+        result.errors.push(`Failed to delete hooks: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // 4. Optionally delete observation data
+    if (!options.keepData) {
+        try {
+            if (existsSync(OBSERVER_DIR)) {
+                rmSync(OBSERVER_DIR, { recursive: true, force: true });
+                result.dataDeleted = true;
+            }
+        }
+        catch (err) {
+            result.errors.push(`Failed to delete observer data: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // 5. Optionally delete config
+    if (!options.keepConfig) {
+        try {
+            if (existsSync(CONFIG_DIR)) {
+                rmSync(CONFIG_DIR, { recursive: true, force: true });
+                result.configDeleted = true;
+            }
+        }
+        catch (err) {
+            result.errors.push(`Failed to delete config: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jobarbiter",
-  "version": "0.3.12",
+  "version": "0.4.0",
   "description": "CLI for JobArbiter — the first AI Proficiency Marketplace",
   "type": "module",
   "bin": {