@xopcai/xopc 0.0.173 → 0.0.174

package/dist/src/focuses/run-processor.js

@@ -0,0 +1,162 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { createFocusActivity, getFocusMonitorByAutomationId, updateFocusMonitorRuntime } from "./repository.js";
+import { createFocusInsight } from "./insight-repository.js";
+//#region src/focuses/run-processor.ts
+init_logger();
+const log = createLogger("FocusRunProcessor");
+function nonEmptyString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function parseFocusMonitorResult(summary) {
+	const start = summary.indexOf("{");
+	const end = summary.lastIndexOf("}");
+	if (start < 0 || end <= start) return null;
+	let value;
+	try {
+		value = JSON.parse(summary.slice(start, end + 1));
+	} catch {
+		return null;
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const result = value;
+	if (result.meaningful === false) return { meaningful: false };
+	if (result.meaningful !== true) return null;
+	const title = nonEmptyString(result.title);
+	const resultSummary = nonEmptyString(result.summary);
+	const whyItMatters = nonEmptyString(result.whyItMatters);
+	const nextAction = nonEmptyString(result.nextAction);
+	const evidence = Array.isArray(result.evidence) ? result.evidence.flatMap((item) => {
+		if (!item || typeof item !== "object" || Array.isArray(item)) return [];
+		const record = item;
+		const label = nonEmptyString(record.label);
+		const source = nonEmptyString(record.source);
+		const publishedAtValue = nonEmptyString(record.publishedAt);
+		const publishedAt = publishedAtValue && Number.isFinite(Date.parse(publishedAtValue)) ? new Date(publishedAtValue).toISOString() : null;
+		return label ? [{
+			label,
+			...source ? { source } : {},
+			...publishedAt ? { publishedAt } : {}
+		}] : [];
+	}).slice(0, 8) : [];
+	if (!title || !resultSummary || !whyItMatters || !nextAction || evidence.length === 0) return null;
+	return {
+		meaningful: true,
+		title,
+		summary: resultSummary,
+		whyItMatters,
+		nextAction,
+		evidence
+	};
+}
+function hasDatedExternalEvidence(evidence) {
+	return evidence.some((item) => {
+		if (!item.source || !item.publishedAt) return false;
+		try {
+			const url = new URL(item.source);
+			return (url.protocol === "https:" || url.protocol === "http:") && Number.isFinite(Date.parse(item.publishedAt));
+		} catch {
+			return false;
+		}
+	});
+}
+function processFocusMonitorRun(run) {
+	const monitor = getFocusMonitorByAutomationId(run.automationId);
+	if (!monitor) return { handled: false };
+	if (monitor.lastRunId === run.id && monitor.lastRunAt != null) return { handled: true };
+	const endedAt = run.endedAtMs ?? Date.now();
+	if (run.status !== "succeeded" || !run.summary) {
+		const errorMessage = run.error || `Monitor run ${run.status}`;
+		updateFocusMonitorRuntime({
+			id: monitor.id,
+			runState: "failed",
+			lastRunId: run.id,
+			lastRunAt: endedAt,
+			error: errorMessage
+		});
+		createFocusActivity({
+			focusId: monitor.focusId,
+			monitorId: monitor.id,
+			type: "run_failed",
+			summary: errorMessage,
+			details: { runId: run.id },
+			nowMs: endedAt
+		});
+		return { handled: true };
+	}
+	const result = parseFocusMonitorResult(run.summary);
+	if (!result || result.meaningful && monitor.kind === "external_changes" && !hasDatedExternalEvidence(result.evidence)) {
+		updateFocusMonitorRuntime({
+			id: monitor.id,
+			runState: "failed",
+			lastRunId: run.id,
+			lastRunAt: endedAt,
+			error: "Monitor returned an invalid result"
+		});
+		createFocusActivity({
+			focusId: monitor.focusId,
+			monitorId: monitor.id,
+			type: "run_failed",
+			summary: "Monitor returned an invalid result",
+			details: { runId: run.id },
+			nowMs: endedAt
+		});
+		log.warn({
+			automationId: run.automationId,
+			runId: run.id,
+			monitorKind: monitor.kind
+		}, "Focus monitor returned an invalid result");
+		return { handled: true };
+	}
+	updateFocusMonitorRuntime({
+		id: monitor.id,
+		runState: "idle",
+		lastRunId: run.id,
+		lastRunAt: endedAt,
+		meaningful: result.meaningful,
+		error: null
+	});
+	if (!result.meaningful) {
+		createFocusActivity({
+			focusId: monitor.focusId,
+			monitorId: monitor.id,
+			type: "run_no_change",
+			summary: "No meaningful change found",
+			details: { runId: run.id },
+			nowMs: endedAt
+		});
+		return { handled: true };
+	}
+	const insight = createFocusInsight({
+		focusId: monitor.focusId,
+		monitorId: monitor.id,
+		runId: run.id,
+		kind: monitor.kind,
+		title: result.title,
+		summary: result.summary,
+		whyItMatters: result.whyItMatters,
+		nextAction: result.nextAction,
+		evidence: result.evidence,
+		nowMs: endedAt
+	});
+	if (insight) {
+		createFocusActivity({
+			focusId: monitor.focusId,
+			monitorId: monitor.id,
+			type: "insight_created",
+			summary: insight.title,
+			details: {
+				runId: run.id,
+				insightId: insight.id
+			},
+			nowMs: endedAt
+		});
+		return {
+			handled: true,
+			insight
+		};
+	}
+	return { handled: true };
+}
+//#endregion
+export { parseFocusMonitorResult, processFocusMonitorRun };

package/dist/src/focuses/service.d.ts

@@ -0,0 +1,42 @@
+import type { Automation, AutomationRun } from '../automations/index.js';
+import type { FocusCadence, FocusDetail, FocusMonitor, FocusMonitorKind, FocusStatus } from './types.js';
+export interface FocusAutomationPort {
+    create(input: Parameters<import('../automations/index.js').AutomationService['create']>[0]): Promise<Automation>;
+    get(id: string): Promise<Automation | null>;
+    update(id: string, input: Parameters<import('../automations/index.js').AutomationService['update']>[1]): Promise<Automation>;
+    pause(id: string): Promise<Automation>;
+    resume(id: string): Promise<Automation>;
+    remove(id: string): Promise<boolean>;
+    runNow(id: string): Promise<AutomationRun>;
+}
+export declare class FocusService {
+    private readonly automations;
+    constructor(automations: FocusAutomationPort);
+    list(statuses?: FocusStatus[]): FocusDetail[];
+    get(id: string): FocusDetail | null;
+    create(input: {
+        title: string;
+        summary: string;
+        projectIds?: string[];
+        goalId?: string;
+    }): FocusDetail;
+    update(id: string, input: {
+        title?: string;
+        summary?: string;
+        projectIds?: string[];
+    }): FocusDetail | null;
+    setStatus(id: string, status: FocusStatus): Promise<FocusDetail | null>;
+    remove(id: string): Promise<boolean>;
+    configureMonitor(input: {
+        focusId: string;
+        kind: FocusMonitorKind;
+        enabled: boolean;
+        cadence?: FocusCadence;
+    }): Promise<{
+        monitor: FocusMonitor;
+        initialRunId?: string;
+    }>;
+    runMonitorNow(focusId: string, kind: FocusMonitorKind): Promise<AutomationRun>;
+    reconcile(): Promise<void>;
+    private detail;
+}

package/dist/src/focuses/service.js

@@ -0,0 +1,241 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { createFocus, createFocusActivity, deleteFocus, getFocus, getFocusMonitor, listAllFocusMonitors, listFocusMonitors, listFocuses, updateFocus, updateFocusMonitorRuntime, upsertFocusMonitor } from "./repository.js";
+import { buildFocusMonitorInstruction } from "./prompts.js";
+//#region src/focuses/service.ts
+init_logger();
+const log = createLogger("FocusService");
+const DEFAULT_CADENCE = {
+	kind: "interval",
+	everyMs: 864e5
+};
+var FocusService = class {
+	constructor(automations) {
+		this.automations = automations;
+	}
+	list(statuses) {
+		return listFocuses({ statuses }).map((focus) => this.detail(focus));
+	}
+	get(id) {
+		const focus = getFocus(id);
+		return focus ? this.detail(focus) : null;
+	}
+	create(input) {
+		if (!input.title.trim()) throw new Error("Focus title is required");
+		const focus = createFocus(input);
+		return this.detail(focus);
+	}
+	update(id, input) {
+		if (input.title !== void 0 && !input.title.trim()) throw new Error("Focus title is required");
+		if (!updateFocus({
+			id,
+			...input
+		})) return null;
+		createFocusActivity({
+			focusId: id,
+			type: "updated",
+			summary: "Focus updated"
+		});
+		return this.get(id);
+	}
+	async setStatus(id, status) {
+		const focus = getFocus(id);
+		if (!focus) return null;
+		if (focus.status === status) return this.detail(focus);
+		const monitors = listFocusMonitors(id);
+		if (status === "active") for (const monitor of monitors.filter((item) => item.enabled && item.automationId)) await this.automations.resume(monitor.automationId);
+		else if (status === "paused") for (const monitor of monitors.filter((item) => item.enabled && item.automationId)) await this.automations.pause(monitor.automationId);
+		else for (const monitor of monitors.filter((item) => item.automationId)) {
+			await this.automations.remove(monitor.automationId);
+			upsertFocusMonitor({
+				focusId: id,
+				kind: monitor.kind,
+				enabled: false,
+				cadence: monitor.cadence,
+				automationId: null
+			});
+		}
+		if (!updateFocus({
+			id,
+			status
+		})) return null;
+		const type = status === "active" ? "resumed" : status === "paused" ? "paused" : "completed";
+		createFocusActivity({
+			focusId: id,
+			type,
+			summary: `Focus ${type}`
+		});
+		return this.get(id);
+	}
+	async remove(id) {
+		if (!getFocus(id)) return false;
+		for (const monitor of listFocusMonitors(id).filter((item) => item.automationId)) await this.automations.remove(monitor.automationId);
+		return deleteFocus(id);
+	}
+	async configureMonitor(input) {
+		const focus = getFocus(input.focusId);
+		if (!focus) throw new Error("Focus not found");
+		if (focus.status !== "active") throw new Error("Only active focuses can enable monitoring");
+		const existing = getFocusMonitor(input.focusId, input.kind);
+		const cadence = input.cadence ?? existing?.cadence ?? DEFAULT_CADENCE;
+		if (cadence.kind !== "interval" || cadence.everyMs < 6e4) throw new Error("Invalid monitor cadence");
+		if (input.enabled && existing?.enabled && existing.cadence.everyMs === cadence.everyMs) return { monitor: existing };
+		if (!input.enabled) {
+			if (existing?.automationId) await this.automations.pause(existing.automationId);
+			const monitor = upsertFocusMonitor({
+				focusId: input.focusId,
+				kind: input.kind,
+				enabled: false,
+				cadence,
+				automationId: existing?.automationId
+			});
+			createFocusActivity({
+				focusId: input.focusId,
+				monitorId: monitor.id,
+				type: "monitor_disabled",
+				summary: `${input.kind} monitoring disabled`
+			});
+			return { monitor };
+		}
+		let monitor = upsertFocusMonitor({
+			focusId: input.focusId,
+			kind: input.kind,
+			enabled: true,
+			runState: "queued",
+			cadence,
+			automationId: existing?.automationId
+		});
+		try {
+			let automation;
+			if (existing?.automationId) if (existing.cadence.everyMs !== cadence.everyMs) automation = await this.automations.update(existing.automationId, { trigger: {
+				kind: "schedule",
+				schedule: {
+					kind: "interval",
+					everyMs: cadence.everyMs
+				}
+			} });
+			else automation = await this.automations.resume(existing.automationId);
+			else automation = await this.automations.create({
+				name: `Monitor: ${focus.title}`.slice(0, 200),
+				description: `${input.kind} monitor for a user-confirmed focus.`,
+				...focus.projectIds[0] ? { projectId: focus.projectIds[0] } : {},
+				trigger: {
+					kind: "schedule",
+					schedule: {
+						kind: "interval",
+						everyMs: cadence.everyMs
+					}
+				},
+				action: {
+					kind: "agent",
+					instruction: buildFocusMonitorInstruction(focus, input.kind),
+					timeoutSeconds: 300
+				},
+				safety: { mode: "suggest_only" },
+				afterRun: { kind: "none" },
+				reliability: {
+					timeoutSeconds: 300,
+					disableAfterConsecutiveFailures: 3
+				}
+			});
+			monitor = upsertFocusMonitor({
+				focusId: input.focusId,
+				kind: input.kind,
+				enabled: true,
+				runState: "queued",
+				cadence,
+				automationId: automation.id
+			});
+			createFocusActivity({
+				focusId: input.focusId,
+				monitorId: monitor.id,
+				type: "monitor_enabled",
+				summary: `${input.kind} monitoring enabled`
+			});
+			const run = await this.automations.runNow(automation.id);
+			monitor = updateFocusMonitorRuntime({
+				id: monitor.id,
+				runState: "running",
+				lastRunId: run.id,
+				nextRunAt: automation.state.nextRunAtMs ?? null
+			}) ?? monitor;
+			createFocusActivity({
+				focusId: input.focusId,
+				monitorId: monitor.id,
+				type: "run_started",
+				summary: "Initial monitor check started",
+				details: { runId: run.id }
+			});
+			return {
+				monitor,
+				initialRunId: run.id
+			};
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			updateFocusMonitorRuntime({
+				id: monitor.id,
+				runState: "failed",
+				error: errorMessage
+			});
+			log.error({
+				err,
+				focusId: input.focusId,
+				monitorKind: input.kind
+			}, `Focus monitor enable failed: ${errorMessage}`);
+			throw err;
+		}
+	}
+	async runMonitorNow(focusId, kind) {
+		const monitor = getFocusMonitor(focusId, kind);
+		if (!monitor?.enabled || !monitor.automationId) throw new Error("Monitor is not enabled");
+		updateFocusMonitorRuntime({
+			id: monitor.id,
+			runState: "queued",
+			error: null
+		});
+		const run = await this.automations.runNow(monitor.automationId);
+		updateFocusMonitorRuntime({
+			id: monitor.id,
+			runState: "running",
+			lastRunId: run.id
+		});
+		createFocusActivity({
+			focusId,
+			monitorId: monitor.id,
+			type: "run_started",
+			summary: "Monitor check started",
+			details: { runId: run.id }
+		});
+		return run;
+	}
+	async reconcile() {
+		for (const monitor of listAllFocusMonitors()) {
+			const focus = getFocus(monitor.focusId);
+			if (!focus) continue;
+			const automation = monitor.automationId ? await this.automations.get(monitor.automationId) : null;
+			if (monitor.enabled && focus.status === "active" && !automation) try {
+				await this.configureMonitor({
+					focusId: focus.id,
+					kind: monitor.kind,
+					enabled: true,
+					cadence: monitor.cadence
+				});
+			} catch (err) {
+				log.warn({
+					err,
+					focusId: focus.id,
+					monitorId: monitor.id
+				}, "Focus monitor reconciliation failed");
+			}
+			else if ((!monitor.enabled || focus.status !== "active") && automation?.enabled) await this.automations.pause(automation.id);
+		}
+	}
+	detail(focus) {
+		return {
+			...focus,
+			monitors: listFocusMonitors(focus.id)
+		};
+	}
+};
+//#endregion
+export { FocusService };

package/dist/src/focuses/types.d.ts

@@ -0,0 +1,89 @@
+export type FocusStatus = 'active' | 'paused' | 'completed';
+export type FocusSource = 'user' | 'discovery';
+export type FocusCandidateStatus = 'pending' | 'accepted' | 'dismissed';
+export type FocusMonitorKind = 'progress' | 'external_changes';
+export type FocusMonitorRunState = 'idle' | 'queued' | 'running' | 'failed';
+export type FocusInsightStatus = 'unread' | 'dismissed' | 'approved';
+export type FocusActivityType = 'created' | 'updated' | 'paused' | 'resumed' | 'completed' | 'monitor_enabled' | 'monitor_disabled' | 'run_started' | 'run_no_change' | 'run_failed' | 'insight_created' | 'insight_dismissed' | 'insight_approved';
+export interface FocusEvidence {
+    label: string;
+    source?: string;
+    publishedAt?: string;
+}
+export interface FocusCandidate {
+    id: string;
+    canonicalKey: string;
+    title: string;
+    summary: string;
+    confidence: number;
+    evidence: FocusEvidence[];
+    projectIds: string[];
+    status: FocusCandidateStatus;
+    discoveredAt: number;
+    updatedAt: number;
+}
+export interface Focus {
+    id: string;
+    title: string;
+    summary: string;
+    status: FocusStatus;
+    source: FocusSource;
+    sourceCandidateId?: string;
+    projectIds: string[];
+    goalId?: string;
+    createdAt: number;
+    updatedAt: number;
+    completedAt?: number;
+    lastActivityAt?: number;
+}
+export interface FocusCadence {
+    kind: 'interval';
+    everyMs: number;
+}
+export interface FocusMonitor {
+    id: string;
+    focusId: string;
+    kind: FocusMonitorKind;
+    enabled: boolean;
+    runState: FocusMonitorRunState;
+    cadence: FocusCadence;
+    automationId?: string;
+    lastRunId?: string;
+    lastRunAt?: number;
+    nextRunAt?: number;
+    lastMeaningfulResultAt?: number;
+    lastError?: string;
+    consecutiveFailures: number;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface FocusActivity {
+    id: string;
+    focusId: string;
+    monitorId?: string;
+    type: FocusActivityType;
+    summary: string;
+    details: Record<string, unknown>;
+    createdAt: number;
+}
+export interface FocusInsight {
+    id: string;
+    focusId: string;
+    monitorId: string;
+    runId: string;
+    kind: FocusMonitorKind;
+    title: string;
+    summary: string;
+    whyItMatters: string;
+    nextAction: string;
+    evidence: FocusEvidence[];
+    status: FocusInsightStatus;
+    valueScore: number;
+    valueReasons: string[];
+    createdAt: number;
+    updatedAt: number;
+}
+export interface FocusDetail extends Focus {
+    monitors: FocusMonitor[];
+    latestInsight?: FocusInsight;
+}

package/dist/src/gateway/heartbeat/service.js

@@ -1,9 +1,9 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { shouldSilence, stripHeartbeatToken } from "../../heartbeat/tokens.js";
+import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { isWithinActiveHours } from "../../heartbeat/active-hours.js";
 import { isHeartbeatContentEmpty } from "../../heartbeat/content-check.js";
-import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { createHeartbeatWake } from "../../heartbeat/wake.js";
 import { resolveHeartbeatMdPath } from "../workspace-heartbeat-path.js";
 import { readFile } from "fs/promises";

package/dist/src/gateway/hono/routes/focuses.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from 'hono';
+import type { AuthenticatedRouteDeps } from './deps.js';
+export declare function registerFocusRoutes(authenticated: Hono, deps: AuthenticatedRouteDeps): void;