@nowcrew/daemon 0.6.88-beta.8 → 0.6.88

package/dist/local-memory/pending-query.js

@@ -1,100 +0,0 @@
-import { createHash } from "node:crypto";
-import { z } from "zod";
-import { isRecallablePending, PendingIdSchema } from "./pending-schema.js";
-import { normalizePendingQuery, pendingRecallScore } from "./pending-match.js";
-import { pendingDirectorySnapshot, pendingSourceError, PENDING_FILE_BYTES, readPendingSource } from "./pending-source.js";
-const PAGE_FILES = 128;
-const PAGE_BYTES = 1_000_000;
-const OUTPUT_BYTES = 12 * 1024;
-const CursorSchema = z.object({
-    v: z.literal(1), queryHash: z.string().regex(/^[a-f0-9]{64}$/u), version: z.string().regex(/^[a-f0-9]{64}$/u),
-    after: z.string().min(1).max(255), hadWarnings: z.boolean(),
-}).strict();
-const SearchSchema = z.object({
-    agentDir: z.string().min(1), query: z.string().trim().min(1).max(256),
-    cursor: z.string().max(2048).optional(), limit: z.number().int().min(1).max(40).default(10),
-}).strict();
-const excerpt = (text, cap) => Array.from(text).slice(0, cap).join("");
-export async function searchPendingMemoryPage(input) {
-    const parsed = SearchSchema.safeParse(input);
-    if (!parsed.success)
-        throw new Error("memory_pending_arguments_invalid");
-    const args = parsed.data;
-    const queryHash = createHash("sha256").update(normalizePendingQuery(args.query)).digest("hex");
-    let cursor;
-    if (args.cursor !== undefined) {
-        try {
-            cursor = CursorSchema.parse(JSON.parse(Buffer.from(args.cursor, "base64url").toString("utf8")));
-        }
-        catch {
-            throw new Error("memory_pending_cursor_invalid");
-        }
-        if (cursor.queryHash !== queryHash)
-            throw new Error("memory_pending_cursor_invalid");
-    }
-    const snapshot = await pendingDirectorySnapshot(args.agentDir);
-    if (cursor && cursor.version !== snapshot.version)
-        throw new Error("memory_pending_source_changed");
-    const initial = cursor ? snapshot.names.indexOf(cursor.after) + 1 : 0;
-    if (cursor && initial === 0)
-        throw new Error("memory_pending_cursor_invalid");
-    const matches = [];
-    const warnings = [];
-    let position = initial;
-    let scannedFiles = 0;
-    let scannedBytes = 0;
-    // 为游标、错误与元数据预留空间；达到输出上限前停止消费来源，不跳过未输出的命中。
-    let outputBytes = 1600;
-    while (position < snapshot.names.length && scannedFiles < PAGE_FILES && scannedBytes + PENDING_FILE_BYTES <= PAGE_BYTES) {
-        const name = snapshot.names[position];
-        let source;
-        let warning;
-        try {
-            source = await readPendingSource(args.agentDir, name);
-        }
-        catch (error) {
-            const code = pendingSourceError(error);
-            if (code === "memory_pending_source_changed" || code === "memory_pending_not_found")
-                throw new Error("memory_pending_source_changed");
-            warning = { file: name, code };
-        }
-        const match = source && isRecallablePending(source.candidate) && pendingRecallScore(source.candidate, args.query) > 0
-            ? { pendingId: source.candidate.pendingId, sha256: source.sha256, title: source.candidate.candidate.title,
-                summary: excerpt(source.candidate.candidate.summary, 180), triggers: source.candidate.candidate.triggers.slice(0, 4),
-                operation: "create", state: "capacity_deferred" }
-            : null;
-        const addition = match ?? warning;
-        const size = addition ? Buffer.byteLength(JSON.stringify(addition), "utf8") + 2 : 0;
-        if (outputBytes + size > OUTPUT_BYTES)
-            break;
-        if (match)
-            matches.push(match);
-        if (warning)
-            warnings.push(warning);
-        outputBytes += size;
-        scannedFiles += 1;
-        scannedBytes += source?.bytes ?? PENDING_FILE_BYTES;
-        position += 1;
-        if (matches.length >= args.limit)
-            break;
-    }
-    if ((await pendingDirectorySnapshot(args.agentDir)).version !== snapshot.version)
-        throw new Error("memory_pending_source_changed");
-    const hasMore = position < snapshot.names.length;
-    const hadWarnings = cursor?.hadWarnings === true || warnings.length > 0;
-    const nextCursor = hasMore ? Buffer.from(JSON.stringify({ v: 1, queryHash, version: snapshot.version,
-        after: snapshot.names[position - 1], hadWarnings })).toString("base64url") : null;
-    return { matches, warnings, scannedFiles, scannedBytes, hasMore, nextCursor, complete: !hasMore && !hadWarnings };
-}
-export async function readPendingMemoryBody(input) {
-    if (!PendingIdSchema.safeParse(input.pendingId).success)
-        throw new Error("memory_pending_id_invalid");
-    const source = await readPendingSource(input.agentDir, `${input.pendingId}.json`);
-    if (input.ifHash !== undefined && input.ifHash !== source.sha256)
-        throw new Error("memory_pending_source_changed");
-    if (!isRecallablePending(source.candidate))
-        throw new Error("memory_pending_not_recallable");
-    const candidate = source.candidate.candidate;
-    return { pendingId: source.candidate.pendingId, sha256: source.sha256, title: candidate.title,
-        operation: "create", state: "capacity_deferred", content: candidate.detailBody };
-}

package/dist/local-memory/pending-schema.js

@@ -1,29 +0,0 @@
-import { z } from "zod";
-import { LocalMemoryChangeSchema, validateLocalMemoryChange } from "./candidate.js";
-// 索引会按分隔符展开触发词；16 个最多 80 UTF-16 单元的输入可产生 0..640 项。
-const ArchivedMemoryChangeSchema = LocalMemoryChangeSchema.extend({
-    triggers: z.array(LocalMemoryChangeSchema.shape.triggers.element).max(640)
-        .refine((triggers) => triggers.reduce((length, trigger) => length + trigger.length, 0) <= 16 * 80),
-});
-export const PendingIdSchema = z.string().max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u);
-export const PendingMemorySchema = z.object({
-    schemaVersion: z.literal(1), pendingId: PendingIdSchema,
-    createdAt: z.string().min(1).max(100), reason: z.literal("index_over_budget"),
-    source: z.object({ executionId: z.string().min(1).max(500), pruneTraceId: z.string().min(1).max(500).nullable() }).strict(),
-    candidate: ArchivedMemoryChangeSchema,
-}).strict();
-export function parsePendingMemoryCandidate(value) {
-    const parsed = PendingMemorySchema.safeParse(value);
-    if (!parsed.success)
-        throw new Error("local_memory_pending_invalid");
-    validateLocalMemoryChange(parsed.data.candidate);
-    return parsed.data;
-}
-export function isRecallablePending(value) {
-    try {
-        return parsePendingMemoryCandidate(value).candidate.operation === "create";
-    }
-    catch {
-        return false;
-    }
-}

package/dist/local-memory/pending-source.js

@@ -1,126 +0,0 @@
-import { constants } from "node:fs";
-import { lstat, open, opendir, realpath } from "node:fs/promises";
-import { createHash } from "node:crypto";
-import { join } from "node:path";
-import { TextDecoder } from "node:util";
-import { parsePendingMemoryCandidate, PendingIdSchema } from "./pending-schema.js";
-export const PENDING_FILE_BYTES = 128 * 1024;
-const DIRECTORY_ENTRY_CAP = 10_000;
-export function pendingSourceError(error) {
-    if (error instanceof Error && /^memory_pending_[a-z_]+$/u.test(error.message))
-        return error.message;
-    return "memory_pending_file_invalid";
-}
-export async function pendingReadDirectory(agentDir) {
-    const root = await realpath(agentDir);
-    let directory = root;
-    for (const part of [".crew", "memory", "pending"]) {
-        directory = join(directory, part);
-        let stat;
-        try {
-            stat = await lstat(directory);
-        }
-        catch (error) {
-            if (error.code === "ENOENT")
-                return { root, directory: null };
-            throw new Error("memory_pending_directory_unreadable");
-        }
-        if (!stat.isDirectory() || stat.isSymbolicLink() || await realpath(directory) !== directory) {
-            throw new Error("memory_pending_path_invalid");
-        }
-    }
-    return { root, directory };
-}
-export async function pendingFileNames(directory) {
-    if (directory === null)
-        return [];
-    const names = [];
-    let inspected = 0;
-    try {
-        for await (const item of await opendir(directory)) {
-            if (++inspected > DIRECTORY_ENTRY_CAP)
-                throw new Error("memory_pending_directory_over_budget");
-            if (item.name.endsWith(".json"))
-                names.push(item.name);
-        }
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.startsWith("memory_pending_"))
-            throw error;
-        throw new Error("memory_pending_directory_unreadable");
-    }
-    return names.sort();
-}
-function version(stat) {
-    return [stat.dev, stat.ino, stat.mode, stat.size, stat.mtimeMs, stat.ctimeMs].join(":");
-}
-export async function pendingDirectorySnapshot(agentDir) {
-    const location = await pendingReadDirectory(agentDir);
-    const names = await pendingFileNames(location.directory);
-    const digest = createHash("sha256").update(location.root);
-    if (location.directory !== null)
-        digest.update(version(await lstat(location.directory)));
-    for (const name of names) {
-        try {
-            digest.update(JSON.stringify([name, version(await lstat(join(location.directory, name)))]));
-        }
-        catch {
-            throw new Error("memory_pending_source_changed");
-        }
-    }
-    return { ...location, names, version: digest.digest("hex") };
-}
-export async function readPendingSource(agentDir, name, byteBudget = PENDING_FILE_BYTES) {
-    if (!name.endsWith(".json") || !PendingIdSchema.safeParse(name.slice(0, -5)).success) {
-        throw new Error("memory_pending_id_invalid");
-    }
-    const { directory } = await pendingReadDirectory(agentDir);
-    if (directory === null)
-        throw new Error("memory_pending_not_found");
-    const path = join(directory, name);
-    const before = await lstat(path).catch(() => { throw new Error("memory_pending_not_found"); });
-    if (!before.isFile() || before.isSymbolicLink())
-        throw new Error("memory_pending_path_invalid");
-    const limit = Math.min(byteBudget, PENDING_FILE_BYTES);
-    if (before.size > limit)
-        throw new Error("memory_pending_file_over_budget");
-    const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
-    try {
-        const opened = await handle.stat();
-        if (!opened.isFile() || version(opened) !== version(before))
-            throw new Error("memory_pending_source_changed");
-        const chunks = [];
-        let bytes = 0;
-        for (;;) {
-            const chunk = Buffer.alloc(Math.min(16 * 1024, limit + 1 - bytes));
-            const { bytesRead } = await handle.read(chunk, 0, chunk.length, null);
-            if (bytesRead === 0)
-                break;
-            bytes += bytesRead;
-            if (bytes > limit)
-                throw new Error("memory_pending_file_over_budget");
-            chunks.push(chunk.subarray(0, bytesRead));
-        }
-        const after = await handle.stat();
-        const currentDirectory = await pendingReadDirectory(agentDir);
-        const current = await lstat(path);
-        if (currentDirectory.directory !== directory || version(after) !== version(opened) || version(current) !== version(opened)) {
-            throw new Error("memory_pending_source_changed");
-        }
-        const buffer = Buffer.concat(chunks);
-        let parsed;
-        try {
-            const raw = new TextDecoder("utf-8", { fatal: true }).decode(buffer);
-            parsed = parsePendingMemoryCandidate(JSON.parse(raw));
-        }
-        catch {
-            throw new Error("memory_pending_file_invalid");
-        }
-        if (`${parsed.pendingId}.json` !== name)
-            throw new Error("memory_pending_id_invalid");
-        return { candidate: parsed, bytes, sha256: createHash("sha256").update(buffer).digest("hex") };
-    }
-    finally {
-        await handle.close();
-    }
-}