agentplane 0.3.6 → 0.3.8

package/dist/adapters/task-backend/task-backend-adapter.d.ts

@@ -1,12 +1,14 @@
-import type { TaskData } from "../../backends/task-backend.js";
+import type { TaskData, TaskSummary, TaskWriteOptions } from "../../backends/task-backend.js";
 import type { TaskBackendPort } from "../../ports/task-backend-port.js";
 import type { CommandContext } from "../../commands/shared/task-backend.js";
 export declare class TaskBackendAdapter implements TaskBackendPort {
     private readonly ctx;
+    readonly listProjectionTasks?: () => Promise<TaskSummary[]>;
     constructor(ctx: CommandContext);
+    get capabilities(): TaskBackendPort["capabilities"];
     listTasks(): Promise<TaskData[]>;
     getTask(id: string): Promise<TaskData | null>;
-    writeTask(task: TaskData): Promise<void>;
+    writeTask(task: TaskData, opts?: TaskWriteOptions): Promise<void>;
     exportProjectionSnapshot(path: string): Promise<void>;
 }
 //# sourceMappingURL=task-backend-adapter.d.ts.map

package/dist/adapters/task-backend/task-backend-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task-backend-adapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/task-backend/task-backend-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAE5E,qBAAa,kBAAmB,YAAW,eAAe;IACxD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAiB;gBAEzB,GAAG,EAAE,cAAc;IAI/B,SAAS,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;IAIhC,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAI7C,SAAS,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAIxC,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAUtD"}
+{"version":3,"file":"task-backend-adapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/task-backend/task-backend-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAC9F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAE5E,qBAAa,kBAAmB,YAAW,eAAe;IACxD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAiB;IACrC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;gBAEhD,GAAG,EAAE,cAAc;IAO/B,IAAI,YAAY,IAAI,eAAe,CAAC,cAAc,CAAC,CASlD;IAED,SAAS,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;IAIhC,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAI7C,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjE,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAUtD"}

package/dist/adapters/task-backend/task-backend-adapter.js

@@ -1,7 +1,20 @@
 export class TaskBackendAdapter {
     ctx;
+    listProjectionTasks;
     constructor(ctx) {
         this.ctx = ctx;
+        this.listProjectionTasks = ctx.taskBackend.listProjectionTasks
+            ? () => ctx.taskBackend.listProjectionTasks()
+            : undefined;
+    }
+    get capabilities() {
+        const { canonical_source, projection, projection_read_mode, reads_from_projection_by_default } = this.ctx.taskBackend.capabilities;
+        return {
+            canonical_source,
+            projection,
+            projection_read_mode,
+            reads_from_projection_by_default,
+        };
     }
     listTasks() {
         return this.ctx.taskBackend.listTasks();
@@ -9,8 +22,8 @@ export class TaskBackendAdapter {
     getTask(id) {
         return this.ctx.taskBackend.getTask(id);
     }
-    writeTask(task) {
-        return this.ctx.taskBackend.writeTask(task);
+    writeTask(task, opts) {
+        return this.ctx.taskBackend.writeTask(task, opts);
     }
     exportProjectionSnapshot(path) {
         const backend = this.ctx.taskBackend;

package/dist/backends/task-backend/local-backend-doc.d.ts

@@ -0,0 +1,5 @@
+import { type TaskWriteOptions } from "./shared.js";
+import { type LocalBackendContext } from "./local-backend-state.js";
+export declare function setLocalTaskDoc(context: LocalBackendContext, taskId: string, doc: string, updatedBy?: string, opts?: TaskWriteOptions): Promise<void>;
+export declare function touchLocalTaskDocMetadata(context: LocalBackendContext, taskId: string, updatedBy?: string, opts?: TaskWriteOptions): Promise<void>;
+//# sourceMappingURL=local-backend-doc.d.ts.map

package/dist/backends/task-backend/local-backend-doc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-backend-doc.d.ts","sourceRoot":"","sources":["../../../src/backends/task-backend/local-backend-doc.ts"],"names":[],"mappings":"AAmBA,OAAO,EAML,KAAK,gBAAgB,EACtB,MAAM,aAAa,CAAC;AACrB,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,0BAA0B,CAAC;AAElC,wBAAsB,eAAe,CACnC,OAAO,EAAE,mBAAmB,EAC5B,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM,EAClB,IAAI,CAAC,EAAE,gBAAgB,GACtB,OAAO,CAAC,IAAI,CAAC,CAmEf;AAED,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,mBAAmB,EAC5B,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,MAAM,EAClB,IAAI,CAAC,EAAE,gBAAgB,GACtB,OAAO,CAAC,IAAI,CAAC,CAuCf"}

package/dist/backends/task-backend/local-backend-doc.js

@@ -0,0 +1,98 @@
+import { readFile } from "node:fs/promises";
+import { applyTaskDocMutations, docChanged, parseTaskReadme, renderTaskReadme, taskDocToSectionMap, taskReadmePath, validateTaskReadmeFrontmatter, withTaskReadmeFrontmatterDefaults, } from "@agentplaneorg/core";
+import { assertExpectedTaskDoc, assertExpectedTaskSection, } from "../../shared/task-doc-conflicts.js";
+import { writeTextIfChanged } from "../../shared/write-if-changed.js";
+import { normalizeDocVersion, nowIso, resolveDocUpdatedByFromFrontmatter, BackendError, mergeTaskDoc, } from "./shared.js";
+import { assertExpectedRevision, storedRevisionFromFrontmatter, taskDocStateFromFrontmatter, } from "./local-backend-state.js";
+export async function setLocalTaskDoc(context, taskId, doc, updatedBy, opts) {
+    const readmePath = taskReadmePath(context.root, taskId);
+    const text = await readFile(readmePath, "utf8");
+    const parsed = parseTaskReadme(text);
+    assertExpectedRevision({
+        taskId,
+        expectedRevision: opts?.expectedRevision,
+        currentRevision: storedRevisionFromFrontmatter(parsed.frontmatter, 1),
+    });
+    const docText = String(doc ?? "");
+    const currentDoc = taskDocStateFromFrontmatter(parsed.frontmatter, parsed.body).doc;
+    if (opts?.expectedCurrentDoc !== undefined) {
+        assertExpectedTaskDoc({ taskId, currentDoc, expectedDoc: opts.expectedCurrentDoc });
+    }
+    if (opts?.expectedCurrentText !== undefined) {
+        if (!opts.expectedSection) {
+            throw new BackendError("expectedSection is required when expectedCurrentText is set", "E_BACKEND");
+        }
+        assertExpectedTaskSection({
+            taskId,
+            currentDoc,
+            section: opts.expectedSection,
+            expectedText: opts.expectedCurrentText,
+        });
+    }
+    let body = parsed.body;
+    const frontmatter = {
+        ...parsed.frontmatter,
+        id: typeof parsed.frontmatter.id === "string" && parsed.frontmatter.id.trim().length > 0
+            ? parsed.frontmatter.id
+            : taskId,
+    };
+    const currentDocVersion = normalizeDocVersion(frontmatter.doc_version);
+    if (docChanged(currentDoc, docText) || !frontmatter.doc_updated_at) {
+        const applied = applyTaskDocMutations(taskDocStateFromFrontmatter(frontmatter, parsed.body), [
+            { kind: "replace-doc", doc: docText },
+            {
+                kind: "touch-doc-meta",
+                updatedBy: resolveDocUpdatedByFromFrontmatter(frontmatter, updatedBy, context.updatedBy),
+                version: currentDocVersion,
+            },
+        ], { now: nowIso() });
+        body = mergeTaskDoc(parsed.body, applied.doc);
+        frontmatter.doc_version = applied.doc_version;
+        frontmatter.doc_updated_at = applied.doc_updated_at;
+        frontmatter.doc_updated_by = applied.doc_updated_by;
+        frontmatter.sections = applied.sections;
+    }
+    else {
+        body = mergeTaskDoc(parsed.body, docText);
+        frontmatter.sections = taskDocToSectionMap(docText);
+    }
+    frontmatter.doc_version = normalizeDocVersion(frontmatter.doc_version, currentDocVersion);
+    validateTaskReadmeFrontmatter(withTaskReadmeFrontmatterDefaults(frontmatter));
+    const next = renderTaskReadme(frontmatter, body);
+    await writeTextIfChanged(readmePath, next.endsWith("\n") ? next : `${next}\n`);
+}
+export async function touchLocalTaskDocMetadata(context, taskId, updatedBy, opts) {
+    const readmePath = taskReadmePath(context.root, taskId);
+    const text = await readFile(readmePath, "utf8");
+    const parsed = parseTaskReadme(text);
+    assertExpectedRevision({
+        taskId,
+        expectedRevision: opts?.expectedRevision,
+        currentRevision: storedRevisionFromFrontmatter(parsed.frontmatter, 1),
+    });
+    const frontmatter = {
+        ...parsed.frontmatter,
+        id: typeof parsed.frontmatter.id === "string" && parsed.frontmatter.id.trim().length > 0
+            ? parsed.frontmatter.id
+            : taskId,
+    };
+    const applied = applyTaskDocMutations(taskDocStateFromFrontmatter(frontmatter, parsed.body), [
+        {
+            kind: "touch-doc-meta",
+            updatedBy: resolveDocUpdatedByFromFrontmatter(frontmatter, updatedBy, context.updatedBy),
+            version: normalizeDocVersion(frontmatter.doc_version),
+        },
+    ], { now: nowIso() });
+    frontmatter.doc_version = applied.doc_version;
+    frontmatter.doc_updated_at = applied.doc_updated_at;
+    frontmatter.doc_updated_by = applied.doc_updated_by;
+    frontmatter.sections =
+        typeof frontmatter.sections === "object" &&
+            frontmatter.sections !== null &&
+            Object.keys(frontmatter.sections).length > 0
+            ? frontmatter.sections
+            : applied.sections;
+    validateTaskReadmeFrontmatter(withTaskReadmeFrontmatterDefaults(frontmatter));
+    const next = renderTaskReadme(frontmatter, parsed.body || "");
+    await writeTextIfChanged(readmePath, next.endsWith("\n") ? next : `${next}\n`);
+}

package/dist/backends/task-backend/local-backend-read.d.ts

@@ -0,0 +1,7 @@
+import { type TaskData, type TaskSummary } from "./shared.js";
+import { type LocalBackendContext } from "./local-backend-state.js";
+export declare function listLocalTasks(context: LocalBackendContext, mode: "full" | "projection"): Promise<TaskData[] | TaskSummary[]>;
+export declare function getLocalTask(context: LocalBackendContext, taskId: string): Promise<TaskData | null>;
+export declare function getLocalTasks(context: LocalBackendContext, taskIds: string[]): Promise<(TaskData | null)[]>;
+export declare function getLocalTaskDoc(context: LocalBackendContext, taskId: string): Promise<string>;
+//# sourceMappingURL=local-backend-read.d.ts.map

package/dist/backends/task-backend/local-backend-read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-backend-read.d.ts","sourceRoot":"","sources":["../../../src/backends/task-backend/local-backend-read.ts"],"names":[],"mappings":"AAoBA,OAAO,EAIL,KAAK,QAAQ,EACb,KAAK,WAAW,EACjB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AA2CpE,wBAAsB,cAAc,CAClC,OAAO,EAAE,mBAAmB,EAC5B,IAAI,EAAE,MAAM,GAAG,YAAY,GAC1B,OAAO,CAAC,QAAQ,EAAE,GAAG,WAAW,EAAE,CAAC,CAkIrC;AAED,wBAAsB,YAAY,CAChC,OAAO,EAAE,mBAAmB,EAC5B,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAiB1B;AAED,wBAAsB,aAAa,CACjC,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,MAAM,EAAE,GAChB,OAAO,CAAC,CAAC,QAAQ,GAAG,IAAI,CAAC,EAAE,CAAC,CAE9B;AAED,wBAAsB,eAAe,CACnC,OAAO,EAAE,mBAAmB,EAC5B,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC,CAGjB"}

package/dist/backends/task-backend/local-backend-read.js

@@ -0,0 +1,186 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { parseTaskReadme, taskReadmePath, validateTaskReadmeFrontmatter, withTaskReadmeFrontmatterDefaults, } from "@agentplaneorg/core";
+import { isRecord } from "../../shared/guards.js";
+import { buildTaskIndexEntry, loadTaskIndex, resolveTaskIndexPath, saveTaskIndex, } from "../task-index.js";
+import { mapLimit, taskRecordToData, validateTaskId, } from "./shared.js";
+function resolveTaskFrontmatterId(frontmatter, fallbackTaskId) {
+    return typeof frontmatter.id === "string" && frontmatter.id.trim().length > 0
+        ? frontmatter.id
+        : fallbackTaskId;
+}
+function taskDataFromParsedReadme(opts) {
+    const frontmatter = validateTaskReadmeFrontmatter(withTaskReadmeFrontmatterDefaults({
+        ...opts.frontmatter,
+        id: resolveTaskFrontmatterId(opts.frontmatter, opts.taskId),
+    }));
+    return taskRecordToData({
+        id: opts.taskId,
+        frontmatter: frontmatter,
+        body: opts.body,
+        readmePath: opts.readmePath,
+    });
+}
+async function readRequiredTask(context, taskId) {
+    const readmePath = taskReadmePath(context.root, taskId);
+    const text = await readFile(readmePath, "utf8");
+    const parsed = parseTaskReadme(text);
+    return taskDataFromParsedReadme({
+        taskId,
+        readmePath,
+        frontmatter: parsed.frontmatter,
+        body: parsed.body,
+    });
+}
+export async function listLocalTasks(context, mode) {
+    const projectionOnly = mode === "projection";
+    const tasks = [];
+    const warnings = [];
+    const entries = await readdir(context.root, { withFileTypes: true }).catch(() => []);
+    const indexPath = resolveTaskIndexPath(context.root);
+    const cachedIndex = await loadTaskIndex(indexPath);
+    const cachedEntryByPath = new Map();
+    if (cachedIndex) {
+        for (const [readmePath, taskId] of Object.entries(cachedIndex.byPath)) {
+            const entry = cachedIndex.byId[taskId];
+            if (entry)
+                cachedEntryByPath.set(readmePath, entry);
+        }
+    }
+    let indexDirty = cachedIndex === null;
+    const nextById = {};
+    const nextByPath = {};
+    const seen = new Set();
+    const dirs = entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .toSorted();
+    const results = await mapLimit(dirs, 32, async (dirName) => {
+        const readmePath = path.join(context.root, dirName, "README.md");
+        let stats;
+        try {
+            stats = await stat(readmePath);
+        }
+        catch {
+            warnings.push(`skip:${dirName}: missing_or_unreadable_readme`);
+            return null;
+        }
+        if (!stats.isFile())
+            return null;
+        const cached = cachedEntryByPath.get(readmePath);
+        if (projectionOnly && cached?.mtimeMs === stats.mtimeMs) {
+            return { output: cached.task, index: cached };
+        }
+        if (cached?.mtimeMs !== stats.mtimeMs) {
+            indexDirty = true;
+        }
+        let text = "";
+        try {
+            text = await readFile(readmePath, "utf8");
+        }
+        catch {
+            warnings.push(`skip:${dirName}: unreadable_readme`);
+            return null;
+        }
+        let parsed;
+        try {
+            parsed = parseTaskReadme(text);
+        }
+        catch {
+            warnings.push(`skip:${dirName}: invalid_readme_frontmatter`);
+            return null;
+        }
+        const frontmatter = parsed.frontmatter;
+        if (!isRecord(frontmatter) || Object.keys(frontmatter).length === 0) {
+            warnings.push(`skip:${dirName}: empty_or_invalid_frontmatter`);
+            return null;
+        }
+        const taskId = resolveTaskFrontmatterId(frontmatter, dirName).trim();
+        let task;
+        try {
+            task = taskDataFromParsedReadme({
+                taskId,
+                readmePath,
+                frontmatter,
+                body: parsed.body,
+            });
+        }
+        catch {
+            warnings.push(`skip:${dirName}: invalid_readme_frontmatter`);
+            return null;
+        }
+        const index = buildTaskIndexEntry(task, readmePath, stats.mtimeMs);
+        return {
+            output: projectionOnly ? index.task : task,
+            index,
+        };
+    });
+    for (const result of results) {
+        if (!result)
+            continue;
+        const taskId = result.index.task.id.trim();
+        if (taskId) {
+            validateTaskId(taskId);
+            if (seen.has(taskId))
+                throw new Error(`Duplicate task id in local backend: ${taskId}`);
+            seen.add(taskId);
+        }
+        tasks.push(result.output);
+        if (taskId) {
+            nextById[taskId] = result.index;
+            nextByPath[result.index.readmePath] = taskId;
+        }
+    }
+    if (cachedIndex && indexDirty === false) {
+        const cachedPaths = Object.keys(cachedIndex.byPath);
+        const nextPaths = Object.keys(nextByPath);
+        if (cachedPaths.length === nextPaths.length) {
+            for (const readmePath of nextPaths) {
+                if (cachedIndex.byPath[readmePath] === nextByPath[readmePath])
+                    continue;
+                indexDirty = true;
+                break;
+            }
+        }
+        else {
+            indexDirty = true;
+        }
+    }
+    if (indexDirty) {
+        try {
+            await saveTaskIndex(indexPath, { schema_version: 2, byId: nextById, byPath: nextByPath });
+        }
+        catch {
+            // Best-effort cache; ignore failures.
+        }
+    }
+    context.setLastListWarnings?.(warnings);
+    return tasks;
+}
+export async function getLocalTask(context, taskId) {
+    const readmePath = taskReadmePath(context.root, taskId);
+    let text = "";
+    try {
+        text = await readFile(readmePath, "utf8");
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === "ENOENT")
+            return null;
+        throw err;
+    }
+    const parsed = parseTaskReadme(text);
+    return taskDataFromParsedReadme({
+        taskId,
+        readmePath,
+        frontmatter: parsed.frontmatter,
+        body: parsed.body,
+    });
+}
+export async function getLocalTasks(context, taskIds) {
+    return await mapLimit(taskIds, 8, async (taskId) => await getLocalTask(context, taskId));
+}
+export async function getLocalTaskDoc(context, taskId) {
+    const task = await readRequiredTask(context, taskId);
+    return task.doc ?? "";
+}

package/dist/backends/task-backend/local-backend-state.d.ts

@@ -0,0 +1,17 @@
+import { type TaskDocMutationState } from "@agentplaneorg/core";
+import { type TaskData } from "./shared.js";
+export type LocalBackendContext = {
+    root: string;
+    updatedBy: string;
+    setLastListWarnings?: (warnings: string[]) => void;
+};
+export declare function storedRevisionFromFrontmatter(frontmatter: Record<string, unknown>, fallback: number): number;
+export declare function assertExpectedRevision(opts: {
+    taskId: string;
+    expectedRevision?: number;
+    currentRevision: number;
+}): void;
+export declare function toTaskDocMutationComments(comments: unknown): TaskDocMutationState["comments"];
+export declare function taskDocStateFromFrontmatter(frontmatter: Record<string, unknown>, body: string): TaskDocMutationState;
+export declare function taskDocStateFromTask(task: Pick<TaskData, "comments" | "doc_updated_by" | "doc_version" | "owner">, doc: string): TaskDocMutationState;
+//# sourceMappingURL=local-backend-state.d.ts.map

package/dist/backends/task-backend/local-backend-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-backend-state.d.ts","sourceRoot":"","sources":["../../../src/backends/task-backend/local-backend-state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAIhE,OAAO,EAAgC,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE1E,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;CACpD,CAAC;AAEF,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,QAAQ,EAAE,MAAM,GACf,MAAM,CAMR;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;CACzB,GAAG,IAAI,CASP;AAED,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,OAAO,GAAG,oBAAoB,CAAC,UAAU,CAAC,CAW7F;AAED,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,IAAI,EAAE,MAAM,GACX,oBAAoB,CAQtB;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,GAAG,gBAAgB,GAAG,aAAa,GAAG,OAAO,CAAC,EAC7E,GAAG,EAAE,MAAM,GACV,oBAAoB,CAQtB"}

package/dist/backends/task-backend/local-backend-state.js

@@ -0,0 +1,50 @@
+import { isRecord } from "../../shared/guards.js";
+import { BackendError, extractTaskDoc } from "./shared.js";
+export function storedRevisionFromFrontmatter(frontmatter, fallback) {
+    return Number.isInteger(frontmatter.revision) &&
+        typeof frontmatter.revision === "number" &&
+        frontmatter.revision > 0
+        ? frontmatter.revision
+        : fallback;
+}
+export function assertExpectedRevision(opts) {
+    if (opts.expectedRevision === undefined)
+        return;
+    const expected = Math.trunc(opts.expectedRevision);
+    if (expected <= 0 || expected === opts.currentRevision)
+        return;
+    throw new BackendError(`Task revision changed concurrently: ${opts.taskId} ` +
+        `(expected revision ${expected}, current revision ${opts.currentRevision})`, "E_BACKEND");
+}
+export function toTaskDocMutationComments(comments) {
+    if (!Array.isArray(comments))
+        return null;
+    const normalized = comments.flatMap((entry) => {
+        if (!isRecord(entry))
+            return [];
+        return [
+            {
+                author: typeof entry.author === "string" ? entry.author : undefined,
+            },
+        ];
+    });
+    return normalized.length > 0 ? normalized : null;
+}
+export function taskDocStateFromFrontmatter(frontmatter, body) {
+    return {
+        doc: extractTaskDoc(body),
+        doc_version: frontmatter.doc_version,
+        doc_updated_by: frontmatter.doc_updated_by,
+        owner: frontmatter.owner,
+        comments: toTaskDocMutationComments(frontmatter.comments),
+    };
+}
+export function taskDocStateFromTask(task, doc) {
+    return {
+        doc,
+        doc_version: task.doc_version,
+        doc_updated_by: task.doc_updated_by,
+        owner: task.owner,
+        comments: toTaskDocMutationComments(task.comments),
+    };
+}

package/dist/backends/task-backend/local-backend-write.d.ts

@@ -0,0 +1,15 @@
+import { type LocalBackendContext } from "./local-backend-state.js";
+import { type TaskData, type TaskWriteOptions } from "./shared.js";
+export declare function generateLocalTaskId(context: Pick<LocalBackendContext, "root">, opts: {
+    length: number;
+    attempts: number;
+}): Promise<string>;
+export declare function writeLocalTask(context: LocalBackendContext, task: TaskData, opts?: TaskWriteOptions): Promise<void>;
+export declare function writeLocalTasks(context: LocalBackendContext, tasks: TaskData[], opts?: TaskWriteOptions): Promise<void>;
+export declare function normalizeLocalTasks(context: LocalBackendContext): Promise<{
+    scanned: number;
+    changed: number;
+}>;
+export declare function exportLocalTasksJson(context: LocalBackendContext, outputPath: string): Promise<void>;
+export declare function exportLocalProjectionSnapshot(context: LocalBackendContext, outputPath: string): Promise<void>;
+//# sourceMappingURL=local-backend-write.d.ts.map

package/dist/backends/task-backend/local-backend-write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-backend-write.d.ts","sourceRoot":"","sources":["../../../src/backends/task-backend/local-backend-write.ts"],"names":[],"mappings":"AAmBA,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAgBL,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACtB,MAAM,aAAa,CAAC;AAErB,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,IAAI,CAAC,mBAAmB,EAAE,MAAM,CAAC,EAC1C,IAAI,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACzC,OAAO,CAAC,MAAM,CAAC,CAmBjB;AAED,wBAAsB,cAAc,CAClC,OAAO,EAAE,mBAAmB,EAC5B,IAAI,EAAE,QAAQ,EACd,IAAI,CAAC,EAAE,gBAAgB,GACtB,OAAO,CAAC,IAAI,CAAC,CAuIf;AAED,wBAAsB,eAAe,CACnC,OAAO,EAAE,mBAAmB,EAC5B,KAAK,EAAE,QAAQ,EAAE,EACjB,IAAI,CAAC,EAAE,gBAAgB,GACtB,OAAO,CAAC,IAAI,CAAC,CAKf;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAuH/C;AAED,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,mBAAmB,EAC5B,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC,CAGf;AAED,wBAAsB,6BAA6B,CACjD,OAAO,EAAE,mBAAmB,EAC5B,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC,CAEf"}