@xopcai/xopc 0.0.180 → 0.0.188

package/dist/src/discussions/live-worker.d.ts

@@ -2,7 +2,7 @@ import type { Config } from '../config/schema.js';
 import type { NotesService } from '../notes/service.js';
 import type { ProjectService } from '../projects/project-service.js';
 import { enrichLiveDiscussion } from './analyzer.js';
-import type { DiscussionCapture } from './types.js';
+import type { DiscussionCapture, DiscussionTranscriptSegment } from './types.js';
 export interface DiscussionLiveWorkerDeps {
     notes: NotesService;
     projects: ProjectService;
@@ -12,21 +12,23 @@ export interface DiscussionLiveWorkerDeps {
         provider: string;
     }>;
     enrichTranscript?: typeof enrichLiveDiscussion;
-    onTranscriptUpdated?: (discussionId: string, sequence: number) => void;
+    onTranscriptUpdated?: (segment: DiscussionTranscriptSegment) => void;
     onDiscussionUpdated?: (capture: DiscussionCapture) => void;
 }
 export declare class DiscussionLiveWorker {
     private readonly deps;
     private readonly intervalMs;
+    private readonly concurrency;
     private readonly owner;
     private readonly objectLinks;
     private timer?;
     private running;
     private stoppedWaiters;
-    constructor(deps: DiscussionLiveWorkerDeps, intervalMs?: number);
+    constructor(deps: DiscussionLiveWorkerDeps, intervalMs?: number, concurrency?: number);
     start(): void;
     stop(): Promise<void>;
     tick(): Promise<void>;
+    private processOne;
     private transcribeSegment;
     private enrichOnce;
     private linkProject;

package/dist/src/discussions/live-worker.js

@@ -21,9 +21,10 @@ var DiscussionLiveWorker = class {
 	timer;
 	running = false;
 	stoppedWaiters = [];
-	constructor(deps, intervalMs = 1e3) {
+	constructor(deps, intervalMs = 1e3, concurrency = 3) {
 		this.deps = deps;
 		this.intervalMs = intervalMs;
+		this.concurrency = concurrency;
 	}
 	start() {
 		if (this.timer) return;
@@ -41,12 +42,22 @@ var DiscussionLiveWorker = class {
 		if (this.running) return;
 		this.running = true;
 		try {
-			const segment = claimNextDiscussionTranscriptSegment(this.owner);
-			if (!segment) return;
+			await Promise.all(Array.from({ length: this.concurrency }, () => this.processOne()));
+		} finally {
+			this.running = false;
+			const waiters = this.stoppedWaiters.splice(0);
+			for (const resolve of waiters) resolve();
+		}
+	}
+	async processOne() {
+		const segment = claimNextDiscussionTranscriptSegment(this.owner);
+		if (!segment) return;
+		try {
 			try {
 				const result = this.deps.transcribeSegment ? await this.deps.transcribeSegment(segment.audioBuffer) : await this.transcribeSegment(segment.audioBuffer);
-				if (!completeDiscussionTranscriptSegment(segment.discussionId, segment.sequence, this.owner, result.text.trim(), result.provider)) return;
-				this.deps.onTranscriptUpdated?.(segment.discussionId, segment.sequence);
+				const completed = completeDiscussionTranscriptSegment(segment.discussionId, segment.sequence, this.owner, result.text.trim(), result.provider);
+				if (!completed) return;
+				this.deps.onTranscriptUpdated?.(completed);
 				await this.enrichOnce(segment.discussionId).catch((error) => {
 					log.warn({
 						err: error,
@@ -56,8 +67,8 @@ var DiscussionLiveWorker = class {
 			} catch (error) {
 				const exhausted = segment.attemptCount >= MAX_ATTEMPTS;
 				const message = error instanceof Error ? error.message : String(error);
-				retryOrFailDiscussionTranscriptSegment(segment.discussionId, segment.sequence, this.owner, message, exhausted);
-				this.deps.onTranscriptUpdated?.(segment.discussionId, segment.sequence);
+				const updated = retryOrFailDiscussionTranscriptSegment(segment.discussionId, segment.sequence, this.owner, message, exhausted);
+				if (updated) this.deps.onTranscriptUpdated?.(updated);
 				log.warn({
 					err: error,
 					discussionId: segment.discussionId,
@@ -65,10 +76,11 @@ var DiscussionLiveWorker = class {
 					exhausted
 				}, `Live discussion transcription failed: ${message}`);
 			}
-		} finally {
-			this.running = false;
-			const waiters = this.stoppedWaiters.splice(0);
-			for (const resolve of waiters) resolve();
+		} catch (error) {
+			log.error({
+				err: error,
+				discussionId: segment.discussionId
+			}, "Unexpected live transcription worker failure");
 		}
 	}
 	async transcribeSegment(buffer, signal) {
@@ -110,7 +122,7 @@ var DiscussionLiveWorker = class {
 		} : void 0;
 		const note = await this.deps.notes.getNote(capture.noteId);
 		if (!note) throw new Error("Discussion note is missing");
-		if (note.title !== enrichment.title) {
+		if (note.title?.startsWith("Discussion ·") && note.title !== enrichment.title) {
 			if (!await this.deps.notes.updateNote(capture.noteId, { title: enrichment.title }, "ai_edit")) throw new Error("Discussion note disappeared while applying the live title");
 		}
 		const updated = updateDiscussionCapture(discussionId, {

package/dist/src/discussions/{worker.d.ts → organizer-worker.d.ts}

@@ -1,18 +1,16 @@
 import type { DiscussionCapture } from './types.js';
-export interface DiscussionWorkerProcessor {
+export interface DiscussionOrganizerProcessor {
     process(capture: DiscussionCapture, owner: string, signal?: AbortSignal): Promise<DiscussionCapture>;
 }
-export declare class DiscussionWorker {
+export declare class DiscussionOrganizerWorker {
     private readonly processor;
     private readonly onUpdated?;
     private readonly intervalMs;
     private readonly owner;
     private timer?;
     private running;
-    private stoppedWaiters;
-    constructor(processor: DiscussionWorkerProcessor, onUpdated?: (capture: DiscussionCapture) => void, intervalMs?: number);
+    constructor(processor: DiscussionOrganizerProcessor, onUpdated?: (capture: DiscussionCapture) => void, intervalMs?: number);
     start(): void;
     stop(): Promise<void>;
     tick(): Promise<void>;
-    private failOrRetry;
 }

package/dist/src/discussions/organizer-worker.js

@@ -0,0 +1,58 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { claimNextDiscussionCapture, getDiscussionCapture, releaseDiscussionWorkLease, updateDiscussionCapture } from "./repository.js";
+import { randomUUID } from "node:crypto";
+//#region src/discussions/organizer-worker.ts
+init_logger();
+const log = createLogger("DiscussionOrganizerWorker");
+var DiscussionOrganizerWorker = class {
+	owner = randomUUID();
+	timer;
+	running = false;
+	constructor(processor, onUpdated, intervalMs = 1e3) {
+		this.processor = processor;
+		this.onUpdated = onUpdated;
+		this.intervalMs = intervalMs;
+	}
+	start() {
+		if (this.timer) return;
+		this.timer = setInterval(() => void this.tick(), this.intervalMs);
+		this.timer.unref();
+		this.tick();
+	}
+	async stop() {
+		if (this.timer) clearInterval(this.timer);
+		this.timer = void 0;
+		while (this.running) await new Promise((resolve) => setTimeout(resolve, 10));
+	}
+	async tick() {
+		if (this.running) return;
+		this.running = true;
+		try {
+			const capture = claimNextDiscussionCapture(this.owner);
+			if (!capture) return;
+			try {
+				await this.processor.process(capture, this.owner);
+				releaseDiscussionWorkLease(capture.id);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				releaseDiscussionWorkLease(capture.id);
+				const updated = getDiscussionCapture(capture.id) && updateDiscussionCapture(capture.id, {
+					status: "needs_attention",
+					failureStage: "organization",
+					failureCode: "organization_failed",
+					failureMessage: message.slice(0, 1e3)
+				}, ["organizing"]);
+				if (updated) this.onUpdated?.(updated);
+				log.warn({
+					err: error,
+					discussionId: capture.id
+				}, `Discussion organization failed: ${message}`);
+			}
+		} finally {
+			this.running = false;
+		}
+	}
+};
+//#endregion
+export { DiscussionOrganizerWorker };

package/dist/src/discussions/organizer.d.ts

@@ -0,0 +1,22 @@
+import type { Config } from '../config/schema.js';
+import type { NotesService } from '../notes/service.js';
+import type { ProjectService } from '../projects/project-service.js';
+import type { DiscussionCapture, DiscussionOrganization } from './types.js';
+export interface DiscussionOrganizerDeps {
+    notes: NotesService;
+    projects: ProjectService;
+    getConfig: () => Config;
+    organizeTranscript?: (transcript: string, capture: DiscussionCapture, signal?: AbortSignal) => Promise<{
+        organization: DiscussionOrganization;
+        modelRef: string;
+    }>;
+    onUpdated?: (capture: DiscussionCapture) => void;
+    onCompleted?: (capture: DiscussionCapture, organization: DiscussionOrganization) => void;
+}
+export declare class DiscussionOrganizer {
+    private readonly deps;
+    private readonly objectLinks;
+    constructor(deps: DiscussionOrganizerDeps);
+    process(capture: DiscussionCapture, _owner: string, signal?: AbortSignal): Promise<DiscussionCapture>;
+    private linkProject;
+}

package/dist/src/discussions/organizer.js

@@ -0,0 +1,92 @@
+import { ObjectLinkService } from "../activity/service.js";
+import { analyzeDiscussion } from "./analyzer.js";
+import { completeDiscussionOrganization, createDiscussionOrganization, updateDiscussionCapture } from "./repository.js";
+import { acceptRankedProject, findExactProjectMention } from "./project-inference.js";
+//#region src/discussions/organizer.ts
+const PROMPT_VERSION = "discussion-organizer-v1";
+var DiscussionOrganizer = class {
+	objectLinks = new ObjectLinkService();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async process(capture, _owner, signal) {
+		const transcript = capture.canonicalTranscript?.trim();
+		const inputHash = capture.canonicalTranscriptSha256;
+		if (!transcript || !inputHash) throw new Error("Canonical discussion transcript is missing");
+		const projects = this.deps.projects.list({
+			status: "active",
+			limit: 100
+		}).items;
+		const result = this.deps.organizeTranscript ? await this.deps.organizeTranscript(transcript, capture, signal) : await analyzeDiscussion({
+			config: this.deps.getConfig(),
+			transcript,
+			projects: projects.map(({ id, name }) => ({
+				id,
+				name
+			})),
+			signal
+		});
+		completeDiscussionOrganization(createDiscussionOrganization({
+			discussionId: capture.id,
+			inputTranscriptSha256: inputHash,
+			promptVersion: PROMPT_VERSION,
+			modelRef: result.modelRef
+		}).id, result.organization);
+		let inferredProject;
+		if (!capture.projectId) {
+			const exact = findExactProjectMention(transcript, projects);
+			const ranked = acceptRankedProject(result.organization, projects);
+			if (exact) inferredProject = {
+				id: exact.id,
+				score: 1,
+				source: "exact_name"
+			};
+			else if (ranked) inferredProject = {
+				...ranked,
+				source: "model"
+			};
+		}
+		const note = await this.deps.notes.getNote(capture.noteId);
+		if (!note) throw new Error("Discussion note is missing");
+		const title = result.organization.title.trim().slice(0, 200);
+		if (note.title?.startsWith("Discussion ·") && title) await this.deps.notes.updateNote(capture.noteId, { title }, "ai_edit");
+		const updated = updateDiscussionCapture(capture.id, {
+			status: "completed",
+			generatedTitle: title,
+			...inferredProject ? {
+				projectId: inferredProject.id,
+				projectInferenceScore: inferredProject.score,
+				projectInferenceSource: inferredProject.source
+			} : {},
+			failureStage: void 0,
+			failureCode: void 0,
+			failureMessage: void 0,
+			completedAt: Date.now()
+		}, ["organizing"]);
+		if (!updated) throw new Error("Discussion changed while applying organization");
+		if (inferredProject) this.linkProject(updated, inferredProject.id);
+		this.deps.onUpdated?.(updated);
+		this.deps.onCompleted?.(updated, result.organization);
+		return updated;
+	}
+	linkProject(capture, projectId) {
+		const project = this.deps.projects.get(projectId);
+		if (!project) return;
+		this.objectLinks.create({
+			id: `discussion:${capture.id}:project`,
+			from: {
+				kind: "note",
+				id: capture.noteId
+			},
+			to: {
+				kind: "project",
+				id: project.id,
+				title: project.name
+			},
+			relation: "belongs_to",
+			source: "agent"
+		});
+	}
+};
+//#endregion
+export { DiscussionOrganizer };

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

@@ -1,15 +1,16 @@
-import type { DiscussionCapture, DiscussionCaptureSettings, DiscussionListResult, DiscussionMetrics, DiscussionStatus, DiscussionTranscriptSegment, ListDiscussionsQuery } from './types.js';
+import type { DiscussionCapture, DiscussionCaptureSettings, DiscussionListResult, DiscussionMetrics, DiscussionOrganization, DiscussionOrganizationRecord, DiscussionStatus, DiscussionTranscriptSegment, ListDiscussionsQuery } from './types.js';
 export interface ClaimedDiscussionTranscriptSegment extends DiscussionTranscriptSegment {
     audioBuffer: Buffer;
 }
 export declare function createDiscussionCapture(capture: DiscussionCapture): DiscussionCapture;
-export declare function getDiscussionCapture(id: string): DiscussionCapture | null;
-export declare function getDiscussionCaptureByClientRequestId(clientRequestId: string): DiscussionCapture | null;
-export declare function getDiscussionCaptureByNoteId(noteId: string): DiscussionCapture | null;
+export declare const getDiscussionCapture: (id: string) => DiscussionCapture;
+export declare const getDiscussionCaptureByClientRequestId: (id: string) => DiscussionCapture;
+export declare const getDiscussionCaptureByNoteId: (id: string) => DiscussionCapture;
 export declare function listDiscussionCaptures(query?: ListDiscussionsQuery): DiscussionListResult;
 export declare function getDiscussionMetrics(): DiscussionMetrics;
 export declare function updateDiscussionCapture(id: string, patch: Partial<Omit<DiscussionCapture, 'id' | 'clientRequestId' | 'noteId' | 'createdAt'>>, expectedStatuses?: DiscussionStatus[]): DiscussionCapture | null;
 export declare function claimNextDiscussionCapture(owner: string, now?: number, leaseMs?: number): DiscussionCapture | null;
+export declare function releaseDiscussionWorkLease(id: string): void;
 export declare function createDiscussionTranscriptSegment(input: {
     discussionId: string;
     sequence: number;
@@ -22,8 +23,18 @@ export declare function createDiscussionTranscriptSegment(input: {
 export declare function getDiscussionTranscriptSegment(discussionId: string, sequence: number): DiscussionTranscriptSegment | null;
 export declare function listDiscussionTranscriptSegments(discussionId: string): DiscussionTranscriptSegment[];
 export declare function claimNextDiscussionTranscriptSegment(owner: string, now?: number, leaseMs?: number): ClaimedDiscussionTranscriptSegment | null;
-export declare function completeDiscussionTranscriptSegment(discussionId: string, sequence: number, owner: string, transcript: string, provider: string): DiscussionTranscriptSegment | null;
+export declare function completeDiscussionTranscriptSegment(discussionId: string, sequence: number, owner: string, text: string, provider: string, language?: string, confidence?: number): DiscussionTranscriptSegment | null;
+export declare function correctDiscussionTranscriptSegment(discussionId: string, sequence: number, displayText: string, expectedRevision: number): DiscussionTranscriptSegment | null;
 export declare function retryOrFailDiscussionTranscriptSegment(discussionId: string, sequence: number, owner: string, error: string, exhausted: boolean): DiscussionTranscriptSegment | null;
 export declare function deleteDiscussionSegmentAudio(discussionId: string): void;
+export declare function createDiscussionOrganization(input: {
+    discussionId: string;
+    inputTranscriptSha256: string;
+    promptVersion: string;
+    modelRef: string;
+}): DiscussionOrganizationRecord;
+export declare function getLatestDiscussionOrganization(discussionId: string): DiscussionOrganizationRecord | null;
+export declare function completeDiscussionOrganization(id: string, organization: DiscussionOrganization): DiscussionOrganizationRecord | null;
+export declare function failDiscussionOrganization(id: string, error: string): void;
 export declare function getDiscussionCaptureSettings(): DiscussionCaptureSettings;
 export declare function acknowledgeDiscussionCaptureConsent(policyVersion: number): DiscussionCaptureSettings;