@xopcai/xopc 0.0.173 → 0.0.175

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

@@ -0,0 +1,61 @@
+import type { Focus, FocusActivity, FocusActivityType, FocusCadence, FocusMonitor, FocusMonitorKind, FocusMonitorRunState, FocusSource, FocusStatus } from './types.js';
+export declare function getFocus(id: string): Focus | null;
+export declare function listFocuses(options?: {
+    statuses?: FocusStatus[];
+    limit?: number;
+}): Focus[];
+export declare function createFocus(input: {
+    title: string;
+    summary: string;
+    source?: FocusSource;
+    sourceCandidateId?: string;
+    projectIds?: string[];
+    goalId?: string;
+    nowMs?: number;
+}): Focus;
+export declare function updateFocus(input: {
+    id: string;
+    title?: string;
+    summary?: string;
+    status?: FocusStatus;
+    projectIds?: string[];
+    nowMs?: number;
+}): Focus | null;
+export declare function deleteFocus(id: string): boolean;
+export declare function getFocusMonitor(focusId: string, kind: FocusMonitorKind): FocusMonitor | null;
+export declare function getFocusMonitorByAutomationId(automationId: string): FocusMonitor | null;
+export declare function listFocusMonitors(focusId: string): FocusMonitor[];
+export declare function listAllFocusMonitors(): FocusMonitor[];
+export declare function upsertFocusMonitor(input: {
+    focusId: string;
+    kind: FocusMonitorKind;
+    enabled: boolean;
+    runState?: FocusMonitorRunState;
+    cadence: FocusCadence;
+    automationId?: string | null;
+    nowMs?: number;
+}): FocusMonitor;
+export declare function updateFocusMonitorRuntime(input: {
+    id: string;
+    runState: FocusMonitorRunState;
+    automationId?: string | null;
+    lastRunId?: string;
+    lastRunAt?: number;
+    nextRunAt?: number | null;
+    meaningful?: boolean;
+    error?: string | null;
+    nowMs?: number;
+}): FocusMonitor | null;
+export declare function createFocusActivity(input: {
+    focusId: string;
+    monitorId?: string;
+    type: FocusActivityType;
+    summary: string;
+    details?: Record<string, unknown>;
+    nowMs?: number;
+}): FocusActivity;
+export declare function listFocusActivities(input: {
+    focusId: string;
+    before?: number;
+    limit?: number;
+}): FocusActivity[];

package/dist/src/focuses/repository.js

@@ -0,0 +1,214 @@
+import { requireXopcDatabase } from "../storage/sqlite/connection.js";
+import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { randomUUID } from "node:crypto";
+//#region src/focuses/repository.ts
+function parseObject(value) {
+	try {
+		const parsed = JSON.parse(value);
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+function parseCadence(value) {
+	const parsed = parseObject(value);
+	return {
+		kind: "interval",
+		everyMs: typeof parsed.everyMs === "number" && parsed.everyMs > 0 ? parsed.everyMs : 864e5
+	};
+}
+function projectIdsForFocus(db, focusId) {
+	return db.prepare("SELECT project_id FROM focus_projects WHERE focus_id = ? ORDER BY created_at, project_id").all(focusId).map((row) => row.project_id);
+}
+function focusFromRow(db, row) {
+	return {
+		id: row.focus_id,
+		title: row.title,
+		summary: row.summary,
+		status: row.status,
+		source: row.source,
+		...row.source_candidate_id ? { sourceCandidateId: row.source_candidate_id } : {},
+		projectIds: projectIdsForFocus(db, row.focus_id),
+		...row.goal_id ? { goalId: row.goal_id } : {},
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+		...row.completed_at != null ? { completedAt: row.completed_at } : {},
+		...row.last_activity_at != null ? { lastActivityAt: row.last_activity_at } : {}
+	};
+}
+function monitorFromRow(row) {
+	return {
+		id: row.monitor_id,
+		focusId: row.focus_id,
+		kind: row.kind,
+		enabled: row.enabled === 1,
+		runState: row.run_state,
+		cadence: parseCadence(row.cadence_json),
+		...row.automation_id ? { automationId: row.automation_id } : {},
+		...row.last_run_id ? { lastRunId: row.last_run_id } : {},
+		...row.last_run_at != null ? { lastRunAt: row.last_run_at } : {},
+		...row.next_run_at != null ? { nextRunAt: row.next_run_at } : {},
+		...row.last_meaningful_result_at != null ? { lastMeaningfulResultAt: row.last_meaningful_result_at } : {},
+		...row.last_error ? { lastError: row.last_error } : {},
+		consecutiveFailures: row.consecutive_failures,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function activityFromRow(row) {
+	return {
+		id: row.activity_id,
+		focusId: row.focus_id,
+		...row.monitor_id ? { monitorId: row.monitor_id } : {},
+		type: row.type,
+		summary: row.summary,
+		details: parseObject(row.details_json),
+		createdAt: row.created_at
+	};
+}
+function getFocus(id) {
+	const { db } = requireXopcDatabase();
+	const row = db.prepare("SELECT * FROM focuses WHERE focus_id = ?").get(id);
+	return row ? focusFromRow(db, row) : null;
+}
+function listFocuses(options = {}) {
+	const statuses = options.statuses ?? ["active", "paused"];
+	if (statuses.length === 0) return [];
+	const limit = Math.max(1, Math.min(200, options.limit ?? 50));
+	const { db } = requireXopcDatabase();
+	return db.prepare(`SELECT * FROM focuses WHERE status IN (${statuses.map(() => "?").join(", ")})
+     ORDER BY COALESCE(last_activity_at, updated_at) DESC LIMIT ?`).all(...statuses, limit).map((row) => focusFromRow(db, row));
+}
+function createFocus(input) {
+	const id = randomUUID();
+	const now = input.nowMs ?? Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO focuses (
+        focus_id, title, summary, status, source, source_candidate_id, goal_id,
+        created_at, updated_at, last_activity_at
+      ) VALUES (?, ?, ?, 'active', ?, ?, ?, ?, ?, ?)`).run(id, input.title.trim().slice(0, 200), input.summary.trim().slice(0, 2e3), input.source ?? "user", input.sourceCandidateId ?? null, input.goalId ?? null, now, now, now);
+		const insertProject = db.prepare("INSERT INTO focus_projects (focus_id, project_id, created_at) VALUES (?, ?, ?)");
+		for (const projectId of [...new Set(input.projectIds ?? [])].slice(0, 20)) insertProject.run(id, projectId, now);
+		insertFocusActivity(db, {
+			focusId: id,
+			type: "created",
+			summary: "Focus created",
+			nowMs: now
+		});
+	});
+	return getFocus(id);
+}
+function updateFocus(input) {
+	const current = getFocus(input.id);
+	if (!current) return null;
+	const now = input.nowMs ?? Date.now();
+	const status = input.status ?? current.status;
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`UPDATE focuses SET title = ?, summary = ?, status = ?, completed_at = ?, updated_at = ?
+       WHERE focus_id = ?`).run(input.title?.trim().slice(0, 200) || current.title, input.summary?.trim().slice(0, 2e3) || current.summary, status, status === "completed" ? current.completedAt ?? now : null, now, input.id);
+		if (input.projectIds) {
+			db.prepare("DELETE FROM focus_projects WHERE focus_id = ?").run(input.id);
+			const insertProject = db.prepare("INSERT INTO focus_projects (focus_id, project_id, created_at) VALUES (?, ?, ?)");
+			for (const projectId of [...new Set(input.projectIds)].slice(0, 20)) insertProject.run(input.id, projectId, now);
+		}
+	});
+	return getFocus(input.id);
+}
+function deleteFocus(id) {
+	let deleted = false;
+	runSqliteWriteTransaction((db) => {
+		deleted = db.prepare("DELETE FROM focuses WHERE focus_id = ?").run(id).changes > 0;
+	});
+	return deleted;
+}
+function getFocusMonitor(focusId, kind) {
+	const { db } = requireXopcDatabase();
+	const row = db.prepare("SELECT * FROM focus_monitors WHERE focus_id = ? AND kind = ?").get(focusId, kind);
+	return row ? monitorFromRow(row) : null;
+}
+function getFocusMonitorByAutomationId(automationId) {
+	const { db } = requireXopcDatabase();
+	const row = db.prepare("SELECT * FROM focus_monitors WHERE automation_id = ?").get(automationId);
+	return row ? monitorFromRow(row) : null;
+}
+function listFocusMonitors(focusId) {
+	const { db } = requireXopcDatabase();
+	return db.prepare("SELECT * FROM focus_monitors WHERE focus_id = ? ORDER BY kind").all(focusId).map(monitorFromRow);
+}
+function listAllFocusMonitors() {
+	const { db } = requireXopcDatabase();
+	return db.prepare("SELECT * FROM focus_monitors ORDER BY updated_at DESC").all().map(monitorFromRow);
+}
+function upsertFocusMonitor(input) {
+	const existing = getFocusMonitor(input.focusId, input.kind);
+	const id = existing?.id ?? randomUUID();
+	const now = input.nowMs ?? Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO focus_monitors (
+        monitor_id, focus_id, kind, enabled, run_state, cadence_json, automation_id,
+        consecutive_failures, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?)
+      ON CONFLICT(focus_id, kind) DO UPDATE SET
+        enabled = excluded.enabled,
+        run_state = excluded.run_state,
+        cadence_json = excluded.cadence_json,
+        automation_id = excluded.automation_id,
+        last_error = CASE WHEN excluded.enabled = 1 THEN NULL ELSE focus_monitors.last_error END,
+        updated_at = excluded.updated_at`).run(id, input.focusId, input.kind, input.enabled ? 1 : 0, input.runState ?? "idle", JSON.stringify(input.cadence), input.automationId === void 0 ? existing?.automationId ?? null : input.automationId, existing?.createdAt ?? now, now);
+	});
+	return getFocusMonitor(input.focusId, input.kind);
+}
+function updateFocusMonitorRuntime(input) {
+	const now = input.nowMs ?? Date.now();
+	let changed = false;
+	runSqliteWriteTransaction((db) => {
+		changed = db.prepare(`UPDATE focus_monitors SET
+        run_state = ?,
+        automation_id = COALESCE(?, automation_id),
+        last_run_id = COALESCE(?, last_run_id),
+        last_run_at = COALESCE(?, last_run_at),
+        next_run_at = CASE WHEN ? = 1 THEN ? ELSE next_run_at END,
+        last_meaningful_result_at = CASE WHEN ? = 1 THEN ? ELSE last_meaningful_result_at END,
+        last_error = ?,
+        consecutive_failures = CASE WHEN ? IS NOT NULL THEN consecutive_failures + 1 ELSE 0 END,
+        updated_at = ?
+       WHERE monitor_id = ?`).run(input.runState, input.automationId ?? null, input.lastRunId ?? null, input.lastRunAt ?? null, input.nextRunAt === void 0 ? 0 : 1, input.nextRunAt ?? null, input.meaningful ? 1 : 0, now, input.error ?? null, input.error ?? null, now, input.id).changes > 0;
+	});
+	if (!changed) return null;
+	const { db } = requireXopcDatabase();
+	return monitorFromRow(db.prepare("SELECT * FROM focus_monitors WHERE monitor_id = ?").get(input.id));
+}
+function insertFocusActivity(db, input) {
+	const id = randomUUID();
+	db.prepare(`INSERT INTO focus_activities (
+      activity_id, focus_id, monitor_id, type, summary, details_json, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(id, input.focusId, input.monitorId ?? null, input.type, input.summary.slice(0, 500), JSON.stringify(input.details ?? {}), input.nowMs);
+	db.prepare("UPDATE focuses SET last_activity_at = ?, updated_at = MAX(updated_at, ?) WHERE focus_id = ?").run(input.nowMs, input.nowMs, input.focusId);
+	return {
+		id,
+		focusId: input.focusId,
+		...input.monitorId ? { monitorId: input.monitorId } : {},
+		type: input.type,
+		summary: input.summary.slice(0, 500),
+		details: input.details ?? {},
+		createdAt: input.nowMs
+	};
+}
+function createFocusActivity(input) {
+	let activity;
+	runSqliteWriteTransaction((db) => {
+		activity = insertFocusActivity(db, {
+			...input,
+			nowMs: input.nowMs ?? Date.now()
+		});
+	});
+	return activity;
+}
+function listFocusActivities(input) {
+	const limit = Math.max(1, Math.min(100, input.limit ?? 30));
+	const { db } = requireXopcDatabase();
+	return db.prepare(`SELECT * FROM focus_activities WHERE focus_id = ? AND created_at < ?
+     ORDER BY created_at DESC, activity_id DESC LIMIT ?`).all(input.focusId, input.before ?? Number.MAX_SAFE_INTEGER, limit).map(activityFromRow);
+}
+//#endregion
+export { createFocus, createFocusActivity, deleteFocus, getFocus, getFocusMonitor, getFocusMonitorByAutomationId, listAllFocusMonitors, listFocusActivities, listFocusMonitors, listFocuses, updateFocus, updateFocusMonitorRuntime, upsertFocusMonitor };

package/dist/src/focuses/run-processor.d.ts

@@ -0,0 +1,18 @@
+import type { AutomationRun } from '../automations/index.js';
+import type { FocusEvidence, FocusInsight } from './types.js';
+interface MeaningfulResult {
+    meaningful: true;
+    title: string;
+    summary: string;
+    whyItMatters: string;
+    nextAction: string;
+    evidence: FocusEvidence[];
+}
+export declare function parseFocusMonitorResult(summary: string): MeaningfulResult | {
+    meaningful: false;
+} | null;
+export declare function processFocusMonitorRun(run: AutomationRun): {
+    handled: boolean;
+    insight?: FocusInsight;
+};
+export {};

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;
+}