@xopcai/xopc 0.0.176 → 0.0.178

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

@@ -1,162 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,241 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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/hono/routes/focuses.d.ts

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