@xopcai/xopc 0.0.178 → 0.0.179

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

@@ -0,0 +1,33 @@
+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';
+export interface DiscussionLiveWorkerDeps {
+    notes: NotesService;
+    projects: ProjectService;
+    getConfig: () => Config;
+    transcribeSegment?: (buffer: Buffer, signal?: AbortSignal) => Promise<{
+        text: string;
+        provider: string;
+    }>;
+    enrichTranscript?: typeof enrichLiveDiscussion;
+    onTranscriptUpdated?: (discussionId: string, sequence: number) => void;
+    onDiscussionUpdated?: (capture: DiscussionCapture) => void;
+}
+export declare class DiscussionLiveWorker {
+    private readonly deps;
+    private readonly intervalMs;
+    private readonly owner;
+    private readonly objectLinks;
+    private timer?;
+    private running;
+    private stoppedWaiters;
+    constructor(deps: DiscussionLiveWorkerDeps, intervalMs?: number);
+    start(): void;
+    stop(): Promise<void>;
+    tick(): Promise<void>;
+    private transcribeSegment;
+    private enrichOnce;
+    private linkProject;
+}

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

@@ -0,0 +1,148 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { ObjectLinkService } from "../activity/service.js";
+import { transcribe } from "../voice/stt/transcribe-core.js";
+import { isSTTAvailable } from "../voice/stt/availability.js";
+import { mergeSttConfigFromAppConfig } from "../voice/stt/config.js";
+import "../voice/stt/index.js";
+import { enrichLiveDiscussion } from "./analyzer.js";
+import { claimNextDiscussionTranscriptSegment, completeDiscussionTranscriptSegment, getDiscussionCapture, listDiscussionTranscriptSegments, retryOrFailDiscussionTranscriptSegment, updateDiscussionCapture } from "./repository.js";
+import { assembleDiscussionTranscript } from "./transcript.js";
+import { acceptRankedProject, findExactProjectMention } from "./project-inference.js";
+import { randomUUID } from "node:crypto";
+//#region src/discussions/live-worker.ts
+init_logger();
+const log = createLogger("DiscussionLiveWorker");
+const MAX_ATTEMPTS = 3;
+const MIN_ENRICHMENT_CHARS = 80;
+var DiscussionLiveWorker = class {
+	owner = randomUUID();
+	objectLinks = new ObjectLinkService();
+	timer;
+	running = false;
+	stoppedWaiters = [];
+	constructor(deps, intervalMs = 1e3) {
+		this.deps = deps;
+		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;
+		if (!this.running) return;
+		await new Promise((resolve) => this.stoppedWaiters.push(resolve));
+	}
+	async tick() {
+		if (this.running) return;
+		this.running = true;
+		try {
+			const segment = claimNextDiscussionTranscriptSegment(this.owner);
+			if (!segment) return;
+			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);
+				await this.enrichOnce(segment.discussionId).catch((error) => {
+					log.warn({
+						err: error,
+						discussionId: segment.discussionId
+					}, "Live discussion enrichment failed");
+				});
+			} 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);
+				log.warn({
+					err: error,
+					discussionId: segment.discussionId,
+					sequence: segment.sequence,
+					exhausted
+				}, `Live discussion transcription failed: ${message}`);
+			}
+		} finally {
+			this.running = false;
+			const waiters = this.stoppedWaiters.splice(0);
+			for (const resolve of waiters) resolve();
+		}
+	}
+	async transcribeSegment(buffer, signal) {
+		const config = this.deps.getConfig();
+		const sttConfig = mergeSttConfigFromAppConfig(config.tools?.media?.audio, config.tools?.media);
+		if (!isSTTAvailable(sttConfig)) throw new Error("STT is not configured");
+		return transcribe(buffer, sttConfig, {
+			mime: "audio/wav",
+			fileName: "discussion-segment.wav",
+			signal
+		});
+	}
+	async enrichOnce(discussionId) {
+		const capture = getDiscussionCapture(discussionId);
+		if (!capture || capture.generatedTitle || capture.status === "cancelled" || capture.status === "completed") return;
+		const transcript = assembleDiscussionTranscript(listDiscussionTranscriptSegments(discussionId));
+		if (transcript.length < MIN_ENRICHMENT_CHARS) return;
+		const projects = this.deps.projects.list({
+			status: "active",
+			limit: 100
+		}).items;
+		const enrichment = await (this.deps.enrichTranscript ?? enrichLiveDiscussion)({
+			config: this.deps.getConfig(),
+			transcript,
+			projects: projects.map(({ id, name }) => ({
+				id,
+				name
+			}))
+		});
+		const exact = capture.projectId ? void 0 : findExactProjectMention(transcript, projects);
+		const ranked = capture.projectId ? void 0 : acceptRankedProject(enrichment, projects);
+		const inferred = exact ? {
+			id: exact.id,
+			score: 1,
+			source: "exact_name"
+		} : ranked ? {
+			...ranked,
+			source: "model"
+		} : 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 (!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, {
+			generatedTitle: enrichment.title,
+			...inferred ? {
+				projectId: inferred.id,
+				projectInferenceScore: inferred.score,
+				projectInferenceSource: inferred.source
+			} : {}
+		}, [capture.status]);
+		if (!updated) return;
+		if (inferred) this.linkProject(updated, inferred.id);
+		this.deps.onDiscussionUpdated?.(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 { DiscussionLiveWorker };

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

@@ -0,0 +1,33 @@
+import type { Config } from '../config/schema.js';
+import type { NotesService } from '../notes/service.js';
+import type { ProjectService } from '../projects/project-service.js';
+import type { DiscussionAnalysis, DiscussionCapture } from './types.js';
+export interface DiscussionTranscriptionResult {
+    text: string;
+    provider: string;
+    language?: string;
+}
+export interface DiscussionPipelineDeps {
+    notes: NotesService;
+    projects: ProjectService;
+    getConfig: () => Config;
+    transcribeAudio?: (buffer: Buffer, capture: DiscussionCapture, signal?: AbortSignal) => Promise<DiscussionTranscriptionResult>;
+    analyzeTranscript?: (transcript: string, capture: DiscussionCapture, signal?: AbortSignal) => Promise<{
+        analysis: DiscussionAnalysis;
+        modelRef: string;
+    }>;
+    onUpdated?: (capture: DiscussionCapture) => void;
+    onCompleted?: (capture: DiscussionCapture, analysis: DiscussionAnalysis) => void;
+}
+export declare function mergeDiscussionAnalysisIntoMarkdown(markdown: string, transcript: string, analysis: DiscussionAnalysis, audioRef?: string): string;
+export declare class DiscussionPipeline {
+    private readonly deps;
+    private readonly objectLinks;
+    constructor(deps: DiscussionPipelineDeps);
+    process(capture: DiscussionCapture, owner: string, signal?: AbortSignal): Promise<DiscussionCapture>;
+    private transcribe;
+    private analyze;
+    private writeNote;
+    private linkProject;
+    private defaultTranscribe;
+}

package/dist/src/discussions/pipeline.js

@@ -0,0 +1,205 @@
+import { buildNoteAttachmentRef } from "../notes/attachment-ref.js";
+import { ObjectLinkService } from "../activity/service.js";
+import { transcribe } from "../voice/stt/transcribe-core.js";
+import { isSTTAvailable } from "../voice/stt/availability.js";
+import { mergeSttConfigFromAppConfig } from "../voice/stt/config.js";
+import "../voice/stt/index.js";
+import { analyzeDiscussion } from "./analyzer.js";
+import { deleteDiscussionSegmentAudio, updateDiscussionCapture } from "./repository.js";
+import { acceptRankedProject, findExactProjectMention } from "./project-inference.js";
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+//#region src/discussions/pipeline.ts
+const MANAGED_START = "<!-- xopc:discussion-analysis:start -->";
+const MANAGED_END = "<!-- xopc:discussion-analysis:end -->";
+function list(values) {
+	return values.length > 0 ? values.map((value) => `- ${value}`).join("\n") : "- None identified";
+}
+function renderManagedSection(transcript, analysis) {
+	const actions = analysis.actionItems.length > 0 ? analysis.actionItems.map((item) => {
+		const metadata = [item.owner ? `Owner: ${item.owner}` : "", item.dueDate ? `Due: ${item.dueDate}` : ""].filter(Boolean).join(" · ");
+		return `- [ ] ${item.title}${metadata ? ` — ${metadata}` : ""}`;
+	}).join("\n") : "- None identified";
+	return [
+		MANAGED_START,
+		"## Summary",
+		analysis.summary,
+		"",
+		"## Key points",
+		list(analysis.keyPoints),
+		"",
+		"## Decisions",
+		list(analysis.decisions),
+		"",
+		"## Action items",
+		actions,
+		"",
+		"## Risks",
+		list(analysis.risks),
+		"",
+		"## Open questions",
+		list(analysis.openQuestions),
+		"",
+		"## Transcript",
+		transcript.trim(),
+		MANAGED_END
+	].join("\n");
+}
+function mergeDiscussionAnalysisIntoMarkdown(markdown, transcript, analysis, audioRef) {
+	const managed = renderManagedSection(transcript, analysis);
+	const withoutPlaceholder = markdown.replace(/^> Recording in progress\. Live transcript will appear here\.\s*$/gm, "").replace(/^> Finalizing recording\.\.\.\s*$/gm, "").replace(/\n{3,}/g, "\n\n").trim();
+	const start = withoutPlaceholder.indexOf(MANAGED_START);
+	const end = withoutPlaceholder.indexOf(MANAGED_END);
+	const base = start >= 0 && end >= start ? `${withoutPlaceholder.slice(0, start).trimEnd()}\n\n${managed}${withoutPlaceholder.slice(end + 37)}`.trim() : `${withoutPlaceholder}\n\n${managed}`.trim();
+	return audioRef && !base.includes(`](${audioRef})`) ? `${base}\n\n[Discussion audio](${audioRef})` : base;
+}
+var DiscussionPipeline = class {
+	objectLinks = new ObjectLinkService();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async process(capture, owner, signal) {
+		let current = capture;
+		if (!current.transcriptRaw) current = await this.transcribe(current, owner, signal);
+		if (!current.analysis) current = await this.analyze(current, owner, signal);
+		return this.writeNote(current);
+	}
+	async transcribe(capture, owner, signal) {
+		if (!capture.audioAttachmentId) throw new Error("Discussion audio attachment is missing");
+		const attachment = await this.deps.notes.getAttachmentPath(capture.noteId, capture.audioAttachmentId);
+		if (!attachment) throw new Error("Discussion audio file is missing");
+		const buffer = await readFile(attachment.filePath);
+		const result = this.deps.transcribeAudio ? await this.deps.transcribeAudio(buffer, capture, signal) : await this.defaultTranscribe(buffer, capture, attachment, signal);
+		const transcript = result.text.trim();
+		if (!transcript) throw new Error("Discussion transcription produced no text");
+		const updated = updateDiscussionCapture(capture.id, {
+			processingStage: "analysis",
+			transcriptRaw: transcript,
+			transcriptSha256: createHash("sha256").update(transcript).digest("hex"),
+			transcriptLanguage: result.language,
+			sttProvider: result.provider,
+			lastErrorCode: void 0,
+			lastErrorMessage: void 0,
+			leaseOwner: owner,
+			leaseExpiresAt: Date.now() + 5 * 6e4
+		}, ["finalizing"]);
+		if (!updated) throw new Error("Discussion changed while transcribing");
+		this.deps.onUpdated?.(updated);
+		return updated;
+	}
+	async analyze(capture, owner, signal) {
+		if (!capture.transcriptRaw) throw new Error("Discussion transcript is missing");
+		const projects = this.deps.projects.list({
+			status: "active",
+			limit: 100
+		}).items;
+		const result = this.deps.analyzeTranscript ? await this.deps.analyzeTranscript(capture.transcriptRaw, capture, signal) : await analyzeDiscussion({
+			config: this.deps.getConfig(),
+			transcript: capture.transcriptRaw,
+			projects: projects.map(({ id, name }) => ({
+				id,
+				name
+			})),
+			signal
+		});
+		const analysis = result.analysis;
+		let inferredProject;
+		if (!capture.projectId) {
+			const exact = findExactProjectMention(capture.transcriptRaw, projects);
+			const ranked = acceptRankedProject(analysis, projects);
+			if (exact) inferredProject = {
+				id: exact.id,
+				score: 1,
+				source: "exact_name"
+			};
+			else if (ranked) inferredProject = {
+				...ranked,
+				source: "model"
+			};
+		}
+		const updated = updateDiscussionCapture(capture.id, {
+			processingStage: "note_write",
+			analysis,
+			analysisInputHash: capture.transcriptSha256,
+			analyzerModelRef: result.modelRef,
+			generatedTitle: analysis.title,
+			...inferredProject ? {
+				projectId: inferredProject.id,
+				projectInferenceScore: inferredProject.score,
+				projectInferenceSource: inferredProject.source
+			} : {},
+			leaseOwner: owner,
+			leaseExpiresAt: Date.now() + 5 * 6e4
+		}, ["finalizing"]);
+		if (!updated) throw new Error("Discussion changed while analyzing");
+		if (inferredProject) this.linkProject(updated, inferredProject.id);
+		this.deps.onUpdated?.(updated);
+		return updated;
+	}
+	async writeNote(capture) {
+		if (!capture.transcriptRaw || !capture.analysis || !capture.audioAttachmentId) throw new Error("Discussion finalization data is incomplete");
+		const note = await this.deps.notes.getNote(capture.noteId);
+		if (!note) throw new Error("Discussion note is missing");
+		const title = capture.analysis.title.trim().slice(0, 200);
+		const audioRef = buildNoteAttachmentRef(capture.noteId, capture.audioAttachmentId);
+		const markdown = mergeDiscussionAnalysisIntoMarkdown(note.markdown, capture.transcriptRaw, capture.analysis, audioRef);
+		const attachments = (note.attachments ?? []).map((attachment) => attachment.id === capture.audioAttachmentId ? {
+			...attachment,
+			transcript: capture.transcriptRaw
+		} : attachment);
+		if (capture.projectId && capture.projectInferenceSource !== "context") this.linkProject(capture, capture.projectId);
+		if (note.title !== title || note.markdown !== markdown || note.status !== "processed") await this.deps.notes.updateNote(capture.noteId, {
+			title,
+			markdown,
+			attachments,
+			status: "processed"
+		}, "ai_edit");
+		const now = Date.now();
+		const updated = updateDiscussionCapture(capture.id, {
+			status: "completed",
+			processingStage: void 0,
+			finalizationRevision: capture.finalizationRevision + 1,
+			completedAt: now,
+			leaseOwner: void 0,
+			leaseExpiresAt: void 0,
+			nextAttemptAt: void 0,
+			lastErrorCode: void 0,
+			lastErrorMessage: void 0
+		}, ["finalizing"]);
+		if (!updated || updated.leaseOwner) throw new Error("Discussion changed while writing the note");
+		deleteDiscussionSegmentAudio(capture.id);
+		this.deps.onUpdated?.(updated);
+		this.deps.onCompleted?.(updated, capture.analysis);
+		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"
+		});
+	}
+	async defaultTranscribe(buffer, capture, attachment, signal) {
+		const config = this.deps.getConfig();
+		const sttConfig = mergeSttConfigFromAppConfig(config.tools?.media?.audio, config.tools?.media);
+		if (!isSTTAvailable(sttConfig)) throw new Error("STT is not configured");
+		return transcribe(buffer, sttConfig, {
+			mime: attachment.mimeType || capture.mimeType,
+			fileName: attachment.fileName,
+			signal
+		});
+	}
+};
+//#endregion
+export { DiscussionPipeline, mergeDiscussionAnalysisIntoMarkdown };

package/dist/src/discussions/project-inference.d.ts

@@ -0,0 +1,13 @@
+export interface DiscussionProjectCandidate {
+    id: string;
+    name: string;
+}
+export declare function findExactProjectMention(transcript: string, projects: DiscussionProjectCandidate[]): DiscussionProjectCandidate | undefined;
+export declare function acceptRankedProject(input: {
+    projectCandidateId?: string;
+    projectConfidence?: number;
+    projectAlternativeConfidence?: number;
+}, projects: DiscussionProjectCandidate[]): {
+    id: string;
+    score: number;
+} | undefined;

package/dist/src/discussions/project-inference.js

@@ -0,0 +1,19 @@
+//#region src/discussions/project-inference.ts
+function findExactProjectMention(transcript, projects) {
+	const normalizedTranscript = normalize(transcript);
+	const matches = projects.filter((project) => normalizedTranscript.includes(normalize(project.name)));
+	return matches.length === 1 ? matches[0] : void 0;
+}
+function acceptRankedProject(input, projects) {
+	const score = input.projectConfidence ?? 0;
+	if (!input.projectCandidateId || !projects.some((project) => project.id === input.projectCandidateId) || score < .85 || score - (input.projectAlternativeConfidence ?? 0) < .15) return void 0;
+	return {
+		id: input.projectCandidateId,
+		score
+	};
+}
+function normalize(value) {
+	return value.normalize("NFKC").toLocaleLowerCase().replace(/\s+/g, " ").trim();
+}
+//#endregion
+export { acceptRankedProject, findExactProjectMention };

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

@@ -0,0 +1,29 @@
+import type { DiscussionCapture, DiscussionCaptureSettings, DiscussionListResult, DiscussionMetrics, 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 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 createDiscussionTranscriptSegment(input: {
+    discussionId: string;
+    sequence: number;
+    audioSha256: string;
+    audioBuffer: Buffer;
+    startedAtMs: number;
+    endedAtMs: number;
+    now?: number;
+}): DiscussionTranscriptSegment;
+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 retryOrFailDiscussionTranscriptSegment(discussionId: string, sequence: number, owner: string, error: string, exhausted: boolean): DiscussionTranscriptSegment | null;
+export declare function deleteDiscussionSegmentAudio(discussionId: string): void;
+export declare function getDiscussionCaptureSettings(): DiscussionCaptureSettings;
+export declare function acknowledgeDiscussionCaptureConsent(policyVersion: number): DiscussionCaptureSettings;