@xopcai/xopc 0.0.158 → 0.0.160

package/dist/src/work-discovery/probe.d.ts

@@ -10,9 +10,31 @@ export declare function previewWorkDiscoveryRoot(rootPath: string): Promise<{
     fingerprint: {
         changedFileCount: number;
         recentAreas: string[];
+        contentSignature: string;
         generatedAt: number;
         branch?: string;
     };
 }>;
 export declare function probeWorkDiscoveryRoot(rootPath: string, signal?: AbortSignal): Promise<WorkContextSnapshot>;
+export declare function readWorkDiscoveryTextExcerpt(input: {
+    rootPath: string;
+    relativePath: string;
+    maxChars?: number;
+    signal?: AbortSignal;
+}): Promise<{
+    relativePath: string;
+    excerpt: string;
+    modifiedAt: number;
+    truncated: boolean;
+}>;
+export declare function searchWorkDiscoveryText(input: {
+    rootPath: string;
+    relativePaths: string[];
+    query: string;
+    signal?: AbortSignal;
+}): Promise<Array<{
+    relativePath: string;
+    excerpt: string;
+    modifiedAt: number;
+}>>;
 export declare function summarizeWorkContextSnapshot(snapshot: WorkContextSnapshot): WorkContextSnapshotSummary;

package/dist/src/work-discovery/probe.js

@@ -3,6 +3,7 @@ import "../projects/index.js";
 import { basename, extname, isAbsolute, relative, resolve, sep } from "node:path";
 import { constants } from "node:fs";
 import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
 import { access, lstat, readFile, readdir, realpath, stat } from "node:fs/promises";
 import { promisify } from "node:util";
 //#region src/work-discovery/probe.ts
@@ -169,6 +170,30 @@ async function gitInfo(root, signal) {
 		return;
 	}
 }
+async function metadataFingerprint(root, signal) {
+	const entries = [];
+	const visit = async (directory, depth) => {
+		if (depth > 2 || entries.length >= 300) return;
+		abortIfNeeded(signal);
+		const children = await readdir(directory, { withFileTypes: true }).catch(() => []);
+		for (const child of children.sort((left, right) => left.name.localeCompare(right.name))) {
+			if (entries.length >= 300) break;
+			if (isSecretFile(child.name)) continue;
+			if (child.isDirectory() && isExcludedDirectory(child.name)) continue;
+			const absolutePath = resolve(directory, child.name);
+			const relativePath = relative(root, absolutePath).replaceAll("\\", "/");
+			if (child.isDirectory()) {
+				await visit(absolutePath, depth + 1);
+				continue;
+			}
+			const info = await lstat(absolutePath).catch(() => null);
+			if (!info?.isFile() || info.isSymbolicLink()) continue;
+			entries.push(`${relativePath}\0${info.size}\0${Math.floor(info.mtimeMs)}`);
+		}
+	};
+	await visit(root, 0);
+	return createHash("sha256").update(entries.join("\n")).digest("hex");
+}
 async function canonicalWorkDiscoveryRoot(input) {
 	const trimmed = input.trim();
 	if (!trimmed || !isAbsolute(trimmed)) throw new Error("An absolute folder path is required");
@@ -181,6 +206,7 @@ async function previewWorkDiscoveryRoot(rootPath) {
 	const canonicalRootPath = await canonicalWorkDiscoveryRoot(rootPath);
 	const inference = inferProjectKind({ workspaceRoot: canonicalRootPath });
 	const git = await gitInfo(canonicalRootPath);
+	const contentSignature = await metadataFingerprint(canonicalRootPath);
 	const recentAreas = Array.from(new Set((git?.changedPaths ?? []).map((path) => {
 		const [first, second] = path.replaceAll("\\", "/").split("/");
 		return second ? `${first}/${second}` : first;
@@ -195,6 +221,7 @@ async function previewWorkDiscoveryRoot(rootPath) {
 			...git?.branch ? { branch: git.branch } : {},
 			changedFileCount: git?.changedPaths.length ?? 0,
 			recentAreas,
+			contentSignature,
 			generatedAt: Date.now()
 		}
 	};
@@ -329,6 +356,66 @@ async function probeWorkDiscoveryRoot(rootPath, signal) {
 		}
 	};
 }
+async function resolveWorkDiscoveryTextFile(rootPath, relativePath) {
+	const root = await canonicalWorkDiscoveryRoot(rootPath);
+	const normalized = relativePath.trim().replaceAll("\\", "/");
+	if (!normalized || isAbsolute(normalized) || normalized.split("/").includes("..")) throw new Error("A safe relative path is required");
+	if (normalized.split("/").some((segment) => isExcludedDirectory(segment)) || isSecretFile(basename(normalized))) throw new Error("The requested path is excluded by the scan policy");
+	if (isLikelyBinary(normalized) || METADATA_ONLY_EXTENSIONS.has(extname(normalized).toLowerCase())) throw new Error("The requested path is not a readable text file");
+	const resolvedPath = await realpath(resolve(root, normalized));
+	if (!isInsideRoot(root, resolvedPath)) throw new Error("The requested path is outside the approved folder");
+	const info = await lstat(resolvedPath);
+	if (!info.isFile() || info.size > MAX_FILE_BYTES * 4) throw new Error("The requested file is not eligible for investigation");
+	return {
+		root,
+		resolvedPath,
+		relativePath: relative(root, resolvedPath),
+		modifiedAt: info.mtimeMs
+	};
+}
+async function readWorkDiscoveryTextExcerpt(input) {
+	abortIfNeeded(input.signal);
+	const file = await resolveWorkDiscoveryTextFile(input.rootPath, input.relativePath);
+	const maxChars = Math.max(500, Math.min(2e4, input.maxChars ?? 8e3));
+	const buffer = await readFile(file.resolvedPath);
+	abortIfNeeded(input.signal);
+	if (buffer.includes(0)) throw new Error("The requested file appears to be binary");
+	const text = buffer.toString("utf8");
+	return {
+		relativePath: file.relativePath,
+		excerpt: text.slice(0, maxChars).trim(),
+		modifiedAt: file.modifiedAt,
+		truncated: text.length > maxChars
+	};
+}
+async function searchWorkDiscoveryText(input) {
+	const query = input.query.trim().slice(0, 120);
+	if (query.length < 2) throw new Error("Search query is too short");
+	const needle = query.toLocaleLowerCase();
+	const results = [];
+	for (const relativePath of input.relativePaths.slice(0, 120)) {
+		abortIfNeeded(input.signal);
+		try {
+			const file = await readWorkDiscoveryTextExcerpt({
+				rootPath: input.rootPath,
+				relativePath,
+				maxChars: 2e4,
+				signal: input.signal
+			});
+			const index = file.excerpt.toLocaleLowerCase().indexOf(needle);
+			if (index < 0) continue;
+			const start = Math.max(0, index - 300);
+			const end = Math.min(file.excerpt.length, index + query.length + 700);
+			results.push({
+				relativePath: file.relativePath,
+				excerpt: file.excerpt.slice(start, end).trim(),
+				modifiedAt: file.modifiedAt
+			});
+			if (results.length >= 8) break;
+		} catch {}
+	}
+	return results;
+}
 function summarizeWorkContextSnapshot(snapshot) {
 	return {
 		projectKind: snapshot.root.projectKind,
@@ -341,4 +428,4 @@ function summarizeWorkContextSnapshot(snapshot) {
 	};
 }
 //#endregion
-export { WORK_DISCOVERY_SCAN_POLICY_VERSION, canonicalWorkDiscoveryRoot, previewWorkDiscoveryRoot, probeWorkDiscoveryRoot, summarizeWorkContextSnapshot };
+export { WORK_DISCOVERY_SCAN_POLICY_VERSION, canonicalWorkDiscoveryRoot, previewWorkDiscoveryRoot, probeWorkDiscoveryRoot, readWorkDiscoveryTextExcerpt, searchWorkDiscoveryText, summarizeWorkContextSnapshot };

package/dist/src/work-discovery/service.d.ts

@@ -1,7 +1,7 @@
 import type { Config } from '../config/schema.js';
 import type { ProjectService } from '../projects/project-service.js';
 import type { SessionIndex } from '../session/manager.js';
-import type { WorkDiscoveryOnboardingState, WorkDiscoveryRecognitionDecision, WorkDiscoveryRun, WorkDiscoverySource } from './types.js';
+import type { WorkDiscoveryCandidate, WorkDiscoveryOnboardingState, WorkDiscoveryRecognitionDecision, WorkDiscoveryRun, WorkDiscoverySource } from './types.js';
 export interface WorkDiscoveryServiceOptions {
     projects: ProjectService;
     sessions: SessionIndex;
@@ -11,19 +11,128 @@ export interface WorkDiscoveryServiceOptions {
 export declare class WorkDiscoveryService {
     private readonly options;
     private readonly abortControllers;
+    private readonly candidateContexts;
     private readonly activity;
     constructor(options: WorkDiscoveryServiceOptions);
     isEnabled(): boolean;
     getOnboardingState(): WorkDiscoveryOnboardingState;
     dismissOnboarding(): WorkDiscoveryOnboardingState;
     getRun(id: string): WorkDiscoveryRun | null;
+    getInvestigation(runId: string): {
+        investigation: import("./types.js").WorkUnderstandingInvestigation;
+        evidence: import("./types.js").WorkUnderstandingEvidenceItem[];
+    };
+    listWorkThreads(options?: {
+        projectId?: string;
+        includeRejected?: boolean;
+        limit?: number;
+    }): import("./types.js").WorkUnderstandingThread[];
+    getWorkThread(id: string): import("./types.js").WorkUnderstandingThread;
+    getSourceLineage(sourceId: string): import("./governance.js").WorkUnderstandingSourceLineage;
+    deleteSourceDerivedData(sourceId: string): {
+        deletedMemoryRecords: number;
+        evidenceCount: number | bigint;
+        deletedThreads: number;
+        retainedThreads: number;
+    };
+    getUnderstandingMetrics(): {
+        completedInvestigations: number;
+        averageToolCalls: number;
+        activeThreads: number;
+        confirmedThreads: number;
+        recognitionConfirmationRate: number;
+        evidenceBySource: {
+            sourceType: string;
+            count: number;
+        }[];
+    };
+    updateWorkThread(input: {
+        id: string;
+        decision: 'confirmed' | 'corrected' | 'rejected' | 'paused' | 'completed';
+        correctedTitle?: string;
+        correctedSummary?: string;
+    }): import("./types.js").WorkUnderstandingThread;
+    discoverCandidates(signal?: AbortSignal): Promise<WorkDiscoveryCandidate[]>;
+    listDirectorySources(): import("./types.js").WorkDiscoveryDirectorySource[];
+    grantDirectorySource(rootPath: string): Promise<import("./types.js").WorkDiscoveryDirectorySource>;
+    checkDirectorySources(): Promise<any[]>;
+    refreshDirectorySourceIfChanged(input: {
+        id: string;
+        idempotencyKey: string;
+    }): Promise<{
+        changed: boolean;
+        refresh: import("./types.js").WorkDiscoverySourceRefresh;
+        reused?: undefined;
+        run?: undefined;
+    } | {
+        changed: boolean;
+        reused: boolean;
+        refresh: import("./types.js").WorkDiscoverySourceRefresh;
+        run: WorkDiscoveryRun;
+    } | {
+        changed: boolean;
+        run: WorkDiscoveryRun;
+        refresh: import("./types.js").WorkDiscoverySourceRefresh;
+        reused?: undefined;
+    }>;
+    revokeDirectorySource(id: string): import("./types.js").WorkDiscoveryDirectorySource;
+    importPersonalContext(rawItems: unknown[], signal?: AbortSignal, runId?: string): Promise<{
+        profileCandidates: {
+            status: "pending" | "accepted";
+            memoryRecordId: string;
+            id: string;
+            category: "role" | "focus" | "technology" | "workflow" | "preference";
+            statement: string;
+            confidence: "high" | "medium" | "low";
+            evidence: string[];
+        }[];
+        workThreads: import("./types.js").WorkUnderstandingThread[];
+        autoRemembered: {
+            status: "pending" | "accepted";
+            memoryRecordId: string;
+            id: string;
+            category: "role" | "focus" | "technology" | "workflow" | "preference";
+            statement: string;
+            confidence: "high" | "medium" | "low";
+            evidence: string[];
+        }[];
+    }>;
+    updatePersonalContextProfile(input: {
+        decisions: Array<{
+            memoryRecordId: string;
+            status: 'accepted' | 'edited' | 'rejected';
+            statement?: string;
+        }>;
+    }): {
+        memoryRecordId: string;
+        status: "rejected" | "accepted" | "edited";
+        statement: string;
+    }[];
+    rescanDirectorySource(input: {
+        id: string;
+        idempotencyKey: string;
+    }): Promise<WorkDiscoveryRun>;
+    startQuickRun(input: {
+        idempotencyKey: string;
+    }): Promise<WorkDiscoveryRun>;
     startRun(input: {
         rootPath: string;
         source: WorkDiscoverySource;
         idempotencyKey: string;
+        candidateContext?: WorkDiscoveryCandidate[];
     }): Promise<WorkDiscoveryRun>;
     private publish;
     private execute;
+    private persistProfileCandidates;
+    updateProfileCandidates(input: {
+        runId: string;
+        decisions: Array<{
+            id: string;
+            status: 'accepted' | 'edited' | 'rejected';
+            statement?: string;
+        }>;
+    }): WorkDiscoveryRun | null;
+    private preserveMemoryRecord;
     cancelRun(id: string): WorkDiscoveryRun | null;
     retryRun(id: string): WorkDiscoveryRun | null;
     submitRecognitionFeedback(input: {