@powerhousedao/knowledge-note 1.0.0

package/dist/document-models/pipeline-queue/v1/gen/schema/zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.d.ts","sourceRoot":"","sources":["../../../../../../document-models/pipeline-queue/v1/gen/schema/zod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,aAAa,EAEb,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,kBAAkB,EAClB,YAAY,EAEZ,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAEpB,KAAK,UAAU,CAAC,CAAC,IAAI,QAAQ,CAAC;KAC3B,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAChC,CAAC,CAAC;AAEH,KAAK,iBAAiB,GAAG,EAAE,CAAC;AAE5B,eAAO,MAAM,mBAAmB,GAAI,GAAG,GAAG,KAAG,CAAC,IAAI,iBACnB,CAAC;AAEhC,eAAO,MAAM,uBAAuB,gGAEI,CAAC;AAEzC,eAAO,MAAM,sBAAsB;;;;;EAKjC,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;EAM3B,CAAC;AAEH,wBAAgB,kBAAkB,IAAI,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,CAU1E;AAED,wBAAgB,uBAAuB,IAAI,CAAC,CAAC,SAAS,CACpD,UAAU,CAAC,iBAAiB,CAAC,CAC9B,CAMA;AAED,wBAAgB,qBAAqB,IAAI,CAAC,CAAC,SAAS,CAClD,UAAU,CAAC,eAAe,CAAC,CAC5B,CAMA;AAED,wBAAgB,oBAAoB,IAAI,CAAC,CAAC,SAAS,CACjD,UAAU,CAAC,cAAc,CAAC,CAC3B,CAMA;AAED,wBAAgB,uBAAuB,IAAI,CAAC,CAAC,SAAS,CACpD,UAAU,CAAC,iBAAiB,CAAC,CAC9B,CAKA;AAED,wBAAgB,mBAAmB,IAAI,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC,CAM5E;AAED,wBAAgB,kBAAkB,IAAI,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,CAW1E;AAED,wBAAgB,uBAAuB,IAAI,CAAC,CAAC,SAAS,CACpD,UAAU,CAAC,iBAAiB,CAAC,CAC9B,CASA;AAED,wBAAgB,mBAAmB,IAAI,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC,CAO5E;AAED,wBAAgB,qBAAqB,IAAI,CAAC,CAAC,SAAS,CAClD,UAAU,CAAC,eAAe,CAAC,CAC5B,CAMA;AAED,wBAAgB,wBAAwB,IAAI,CAAC,CAAC,SAAS,CACrD,UAAU,CAAC,kBAAkB,CAAC,CAC/B,CAUA;AAED,wBAAgB,kBAAkB,IAAI,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,CAgB1E;AAED,wBAAgB,sBAAsB,IAAI,CAAC,CAAC,SAAS,CACnD,UAAU,CAAC,gBAAgB,CAAC,CAC7B,CAKA"}

package/dist/document-models/pipeline-queue/v1/gen/schema/zod.js

@@ -0,0 +1,134 @@
+import * as z from "zod";
+export const isDefinedNonNullAny = (v) => v !== undefined && v !== null;
+export const definedNonNullAnySchema = z
+    .any()
+    .refine((v) => isDefinedNonNullAny(v));
+export const LearningCategorySchema = z.enum([
+    "FRICTION",
+    "METHODOLOGY",
+    "PROCESS_GAP",
+    "SURPRISE",
+]);
+export const TaskStatusSchema = z.enum([
+    "BLOCKED",
+    "DONE",
+    "FAILED",
+    "IN_PROGRESS",
+    "PENDING",
+]);
+export function AddTaskInputSchema() {
+    return z.object({
+        batchId: z.string().nullish(),
+        createdAt: z.iso.datetime(),
+        currentPhase: z.string().nullish(),
+        documentRef: z.string().nullish(),
+        id: z.string(),
+        target: z.string(),
+        taskType: z.string(),
+    });
+}
+export function AdvancePhaseInputSchema() {
+    return z.object({
+        handoff: z.lazy(() => PhaseHandoffInputSchema()),
+        taskId: z.string(),
+        updatedAt: z.iso.datetime(),
+    });
+}
+export function AssignTaskInputSchema() {
+    return z.object({
+        assignedTo: z.string(),
+        taskId: z.string(),
+        updatedAt: z.iso.datetime(),
+    });
+}
+export function BlockTaskInputSchema() {
+    return z.object({
+        reason: z.string(),
+        taskId: z.string(),
+        updatedAt: z.iso.datetime(),
+    });
+}
+export function CompleteTaskInputSchema() {
+    return z.object({
+        taskId: z.string(),
+        updatedAt: z.iso.datetime(),
+    });
+}
+export function FailTaskInputSchema() {
+    return z.object({
+        reason: z.string(),
+        taskId: z.string(),
+        updatedAt: z.iso.datetime(),
+    });
+}
+export function PhaseHandoffSchema() {
+    return z.object({
+        __typename: z.literal("PhaseHandoff").optional(),
+        completedAt: z.iso.datetime(),
+        completedBy: z.string().nullish(),
+        filesModified: z.array(z.string()),
+        id: z.string(),
+        learnings: z.array(z.lazy(() => PhaseLearningSchema())),
+        phase: z.string(),
+        workDone: z.string(),
+    });
+}
+export function PhaseHandoffInputSchema() {
+    return z.object({
+        completedAt: z.iso.datetime(),
+        completedBy: z.string().nullish(),
+        filesModified: z.array(z.string()),
+        id: z.string(),
+        phase: z.string(),
+        workDone: z.string(),
+    });
+}
+export function PhaseLearningSchema() {
+    return z.object({
+        __typename: z.literal("PhaseLearning").optional(),
+        category: LearningCategorySchema,
+        description: z.string(),
+        id: z.string(),
+    });
+}
+export function PhaseOrderEntrySchema() {
+    return z.object({
+        __typename: z.literal("PhaseOrderEntry").optional(),
+        phases: z.array(z.string()),
+        taskType: z.string(),
+    });
+}
+export function PipelineQueueStateSchema() {
+    return z.object({
+        __typename: z.literal("PipelineQueueState").optional(),
+        activeCount: z.number(),
+        completedCount: z.number(),
+        lastProcessedAt: z.iso.datetime().nullish(),
+        phaseOrder: z.array(z.lazy(() => PhaseOrderEntrySchema())),
+        schemaVersion: z.number(),
+        tasks: z.array(z.lazy(() => PipelineTaskSchema())),
+    });
+}
+export function PipelineTaskSchema() {
+    return z.object({
+        __typename: z.literal("PipelineTask").optional(),
+        assignedTo: z.string().nullish(),
+        batchId: z.string().nullish(),
+        completedPhases: z.array(z.string()),
+        createdAt: z.iso.datetime(),
+        currentPhase: z.string().nullish(),
+        documentRef: z.string().nullish(),
+        handoffs: z.array(z.lazy(() => PhaseHandoffSchema())),
+        id: z.string(),
+        status: TaskStatusSchema,
+        target: z.string(),
+        taskType: z.string(),
+        updatedAt: z.iso.datetime().nullish(),
+    });
+}
+export function UnblockTaskInputSchema() {
+    return z.object({
+        taskId: z.string(),
+        updatedAt: z.iso.datetime(),
+    });
+}

package/dist/document-models/pipeline-queue/v1/gen/types.d.ts

@@ -0,0 +1,12 @@
+import type { PHDocument, PHBaseState } from "document-model";
+import type { PipelineQueueAction } from "./actions.js";
+import type { PipelineQueueState as PipelineQueueGlobalState } from "./schema/types.js";
+type PipelineQueueLocalState = Record<PropertyKey, never>;
+type PipelineQueuePHState = PHBaseState & {
+    global: PipelineQueueGlobalState;
+    local: PipelineQueueLocalState;
+};
+type PipelineQueueDocument = PHDocument<PipelineQueuePHState>;
+export * from "./schema/types.js";
+export type { PipelineQueueGlobalState, PipelineQueueLocalState, PipelineQueuePHState, PipelineQueueAction, PipelineQueueDocument, };
+//# sourceMappingURL=types.d.ts.map

package/dist/document-models/pipeline-queue/v1/gen/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../document-models/pipeline-queue/v1/gen/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,KAAK,EAAE,kBAAkB,IAAI,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAExF,KAAK,uBAAuB,GAAG,MAAM,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;AAE1D,KAAK,oBAAoB,GAAG,WAAW,GAAG;IACxC,MAAM,EAAE,wBAAwB,CAAC;IACjC,KAAK,EAAE,uBAAuB,CAAC;CAChC,CAAC;AACF,KAAK,qBAAqB,GAAG,UAAU,CAAC,oBAAoB,CAAC,CAAC;AAE9D,cAAc,mBAAmB,CAAC;AAElC,YAAY,EACV,wBAAwB,EACxB,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACnB,qBAAqB,GACtB,CAAC"}

package/dist/document-models/pipeline-queue/v1/gen/types.js

@@ -0,0 +1 @@
+export * from "./schema/types.js";

package/dist/document-models/pipeline-queue/v1/gen/utils.d.ts

@@ -0,0 +1,15 @@
+import type { DocumentModelUtils } from "document-model";
+import type { PipelineQueueGlobalState, PipelineQueueLocalState } from "./types.js";
+import type { PipelineQueuePHState } from "./types.js";
+export declare const initialGlobalState: PipelineQueueGlobalState;
+export declare const initialLocalState: PipelineQueueLocalState;
+export declare const utils: DocumentModelUtils<PipelineQueuePHState>;
+export declare const createDocument: import("document-model").CreateDocument<PipelineQueuePHState>;
+export declare const createState: import("document-model").CreateState<PipelineQueuePHState>;
+export declare const saveToFileHandle: import("document-model").SaveToFileHandle;
+export declare const loadFromInput: import("document-model").LoadFromInput<PipelineQueuePHState>;
+export declare const isStateOfType: import("document-model").IsStateOfType<PipelineQueuePHState>;
+export declare const assertIsStateOfType: import("document-model").AssertIsStateOfType<PipelineQueuePHState>;
+export declare const isDocumentOfType: import("document-model").IsDocumentOfType<PipelineQueuePHState>;
+export declare const assertIsDocumentOfType: import("document-model").AssertIsDocumentOfType<PipelineQueuePHState>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/document-models/pipeline-queue/v1/gen/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../document-models/pipeline-queue/v1/gen/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAQzD,OAAO,KAAK,EACV,wBAAwB,EACxB,uBAAuB,EACxB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAUvD,eAAO,MAAM,kBAAkB,EAAE,wBAahC,CAAC;AACF,eAAO,MAAM,iBAAiB,EAAE,uBAA4B,CAAC;AAE7D,eAAO,MAAM,KAAK,EAAE,kBAAkB,CAAC,oBAAoB,CAqC1D,CAAC;AAEF,eAAO,MAAM,cAAc,+DAAuB,CAAC;AACnD,eAAO,MAAM,WAAW,4DAAoB,CAAC;AAC7C,eAAO,MAAM,gBAAgB,2CAAyB,CAAC;AACvD,eAAO,MAAM,aAAa,8DAAsB,CAAC;AACjD,eAAO,MAAM,aAAa,8DAAsB,CAAC;AACjD,eAAO,MAAM,mBAAmB,oEAA4B,CAAC;AAC7D,eAAO,MAAM,gBAAgB,iEAAyB,CAAC;AACvD,eAAO,MAAM,sBAAsB,uEAA+B,CAAC"}

package/dist/document-models/pipeline-queue/v1/gen/utils.js

@@ -0,0 +1,62 @@
+import { baseCreateDocument, baseSaveToFileHandle, baseLoadFromInput, defaultBaseState, generateId, } from "document-model/core";
+import { reducer } from "./reducer.js";
+import { pipelineQueueDocumentType } from "./document-type.js";
+import { isPipelineQueueDocument, assertIsPipelineQueueDocument, isPipelineQueueState, assertIsPipelineQueueState, } from "./document-schema.js";
+export const initialGlobalState = {
+    schemaVersion: 3,
+    phaseOrder: [
+        { taskType: "claim", phases: ["create", "reflect", "reweave", "verify"] },
+        {
+            taskType: "enrichment",
+            phases: ["enrich", "reflect", "reweave", "verify"],
+        },
+    ],
+    tasks: [],
+    completedCount: 0,
+    activeCount: 0,
+    lastProcessedAt: null,
+};
+export const initialLocalState = {};
+export const utils = {
+    fileExtension: "pq.phd",
+    createState(state) {
+        return {
+            ...defaultBaseState(),
+            global: { ...initialGlobalState, ...state?.global },
+            local: { ...initialLocalState, ...state?.local },
+        };
+    },
+    createDocument(state) {
+        const document = baseCreateDocument(utils.createState, state);
+        document.header.documentType = pipelineQueueDocumentType;
+        // for backwards compatibility, but this is NOT a valid signed document id
+        document.header.id = generateId();
+        return document;
+    },
+    saveToFileHandle(document, input) {
+        return baseSaveToFileHandle(document, input);
+    },
+    loadFromInput(input) {
+        return baseLoadFromInput(input, reducer);
+    },
+    isStateOfType(state) {
+        return isPipelineQueueState(state);
+    },
+    assertIsStateOfType(state) {
+        return assertIsPipelineQueueState(state);
+    },
+    isDocumentOfType(document) {
+        return isPipelineQueueDocument(document);
+    },
+    assertIsDocumentOfType(document) {
+        return assertIsPipelineQueueDocument(document);
+    },
+};
+export const createDocument = utils.createDocument;
+export const createState = utils.createState;
+export const saveToFileHandle = utils.saveToFileHandle;
+export const loadFromInput = utils.loadFromInput;
+export const isStateOfType = utils.isStateOfType;
+export const assertIsStateOfType = utils.assertIsStateOfType;
+export const isDocumentOfType = utils.isDocumentOfType;
+export const assertIsDocumentOfType = utils.assertIsDocumentOfType;

package/dist/document-models/pipeline-queue/v1/hooks.d.ts

@@ -0,0 +1,14 @@
+import type { DocumentDispatch } from "@powerhousedao/reactor-browser";
+import type { PipelineQueueAction, PipelineQueueDocument } from "@powerhousedao/knowledge-note/document-models/pipeline-queue/v1";
+/** Hook to get a PipelineQueue document by its id */
+export declare function usePipelineQueueDocumentById(documentId: string | null | undefined): [PipelineQueueDocument, DocumentDispatch<PipelineQueueAction>] | [undefined, undefined];
+/** Hook to get the selected PipelineQueue document */
+export declare function useSelectedPipelineQueueDocument(): [
+    PipelineQueueDocument,
+    DocumentDispatch<PipelineQueueAction>
+];
+/** Hook to get all PipelineQueue documents in the selected drive */
+export declare function usePipelineQueueDocumentsInSelectedDrive(): PipelineQueueDocument[] | undefined;
+/** Hook to get all PipelineQueue documents in the selected folder */
+export declare function usePipelineQueueDocumentsInSelectedFolder(): PipelineQueueDocument[] | undefined;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/document-models/pipeline-queue/v1/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../../document-models/pipeline-queue/v1/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAOvE,OAAO,KAAK,EACV,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,iEAAiE,CAAC;AAMzE,qDAAqD;AACrD,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAEnC,CAAC,qBAAqB,EAAE,gBAAgB,CAAC,mBAAmB,CAAC,CAAC,GAC9D,CAAC,SAAS,EAAE,SAAS,CAAC,CAIzB;AAED,sDAAsD;AACtD,wBAAgB,gCAAgC,IAAI;IAClD,qBAAqB;IACrB,gBAAgB,CAAC,mBAAmB,CAAC;CACtC,CAKA;AAED,oEAAoE;AACpE,wBAAgB,wCAAwC,wCAGvD;AAED,qEAAqE;AACrE,wBAAgB,yCAAyC,wCAGxD"}

package/dist/document-models/pipeline-queue/v1/hooks.js

@@ -0,0 +1,25 @@
+import { useDocumentById, useDocumentsInSelectedDrive, useDocumentsInSelectedFolder, useSelectedDocument, } from "@powerhousedao/reactor-browser";
+import { assertIsPipelineQueueDocument, isPipelineQueueDocument, } from "./gen/document-schema.js";
+/** Hook to get a PipelineQueue document by its id */
+export function usePipelineQueueDocumentById(documentId) {
+    const [document, dispatch] = useDocumentById(documentId);
+    if (!isPipelineQueueDocument(document))
+        return [undefined, undefined];
+    return [document, dispatch];
+}
+/** Hook to get the selected PipelineQueue document */
+export function useSelectedPipelineQueueDocument() {
+    const [document, dispatch] = useSelectedDocument();
+    assertIsPipelineQueueDocument(document);
+    return [document, dispatch];
+}
+/** Hook to get all PipelineQueue documents in the selected drive */
+export function usePipelineQueueDocumentsInSelectedDrive() {
+    const documentsInSelectedDrive = useDocumentsInSelectedDrive();
+    return documentsInSelectedDrive?.filter(isPipelineQueueDocument);
+}
+/** Hook to get all PipelineQueue documents in the selected folder */
+export function usePipelineQueueDocumentsInSelectedFolder() {
+    const documentsInSelectedFolder = useDocumentsInSelectedFolder();
+    return documentsInSelectedFolder?.filter(isPipelineQueueDocument);
+}

package/dist/document-models/pipeline-queue/v1/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./gen/index.js";
+export * from "./src/index.js";
+export * from "./hooks.js";
+export { actions } from "./actions.js";
+export { utils } from "./utils.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/document-models/pipeline-queue/v1/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../document-models/pipeline-queue/v1/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC"}

package/dist/document-models/pipeline-queue/v1/index.js

@@ -0,0 +1,5 @@
+export * from "./gen/index.js";
+export * from "./src/index.js";
+export * from "./hooks.js";
+export { actions } from "./actions.js";
+export { utils } from "./utils.js";

package/dist/document-models/pipeline-queue/v1/module.d.ts

@@ -0,0 +1,5 @@
+import type { DocumentModelModule } from "document-model";
+import type { PipelineQueuePHState } from "./gen/types.js";
+/** Document model module for the PipelineQueue document type */
+export declare const PipelineQueue: DocumentModelModule<PipelineQueuePHState>;
+//# sourceMappingURL=module.d.ts.map

package/dist/document-models/pipeline-queue/v1/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../document-models/pipeline-queue/v1/module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAG1D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAM3D,gEAAgE;AAChE,eAAO,MAAM,aAAa,EAAE,mBAAmB,CAAC,oBAAoB,CAMnE,CAAC"}

package/dist/document-models/pipeline-queue/v1/module.js

@@ -0,0 +1,14 @@
+import { createState } from "document-model";
+import { defaultBaseState } from "document-model/core";
+import { documentModel } from "./gen/document-model.js";
+import { reducer } from "./gen/reducer.js";
+import { actions } from "./actions.js";
+import { utils } from "./utils.js";
+/** Document model module for the PipelineQueue document type */
+export const PipelineQueue = {
+    version: 1,
+    reducer,
+    actions,
+    utils,
+    documentModel: createState(defaultBaseState(), documentModel),
+};

package/dist/document-models/pipeline-queue/v1/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./utils.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/document-models/pipeline-queue/v1/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../document-models/pipeline-queue/v1/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/dist/document-models/pipeline-queue/v1/src/index.js

@@ -0,0 +1 @@
+export * from "./utils.js";

package/dist/document-models/pipeline-queue/v1/src/reducers/queue-management.d.ts

@@ -0,0 +1,3 @@
+import type { PipelineQueueQueueManagementOperations } from "@powerhousedao/knowledge-note/document-models/pipeline-queue/v1";
+export declare const pipelineQueueQueueManagementOperations: PipelineQueueQueueManagementOperations;
+//# sourceMappingURL=queue-management.d.ts.map

package/dist/document-models/pipeline-queue/v1/src/reducers/queue-management.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-management.d.ts","sourceRoot":"","sources":["../../../../../../document-models/pipeline-queue/v1/src/reducers/queue-management.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sCAAsC,EAAE,MAAM,iEAAiE,CAAC;AAM9H,eAAO,MAAM,sCAAsC,EAAE,sCAoGlD,CAAC"}

package/dist/document-models/pipeline-queue/v1/src/reducers/queue-management.js

@@ -0,0 +1,103 @@
+import { TaskNotFoundError, InvalidTaskStatusError, } from "../../gen/queue-management/error.js";
+export const pipelineQueueQueueManagementOperations = {
+    addTaskOperation(state, action) {
+        const phaseEntry = state.phaseOrder.find((p) => p.taskType === action.input.taskType);
+        const firstPhase = action.input.currentPhase || (phaseEntry ? phaseEntry.phases[0] : null);
+        state.tasks.push({
+            id: action.input.id,
+            taskType: action.input.taskType,
+            status: "PENDING",
+            target: action.input.target,
+            batchId: action.input.batchId || null,
+            documentRef: action.input.documentRef || null,
+            currentPhase: firstPhase || null,
+            completedPhases: [],
+            handoffs: [],
+            assignedTo: null,
+            createdAt: action.input.createdAt,
+            updatedAt: null,
+        });
+        state.activeCount = (state.activeCount || 0) + 1;
+    },
+    assignTaskOperation(state, action) {
+        const task = state.tasks.find((t) => t.id === action.input.taskId);
+        if (!task)
+            throw new TaskNotFoundError("Task not found");
+        task.assignedTo = action.input.assignedTo;
+        task.status = "IN_PROGRESS";
+        task.updatedAt = action.input.updatedAt;
+        state.lastProcessedAt = action.input.updatedAt;
+    },
+    advancePhaseOperation(state, action) {
+        const task = state.tasks.find((t) => t.id === action.input.taskId);
+        if (!task)
+            throw new TaskNotFoundError("Task not found");
+        const handoff = action.input.handoff;
+        task.handoffs.push({
+            id: handoff.id,
+            phase: handoff.phase,
+            workDone: handoff.workDone,
+            filesModified: handoff.filesModified,
+            learnings: [],
+            completedAt: handoff.completedAt,
+            completedBy: handoff.completedBy || null,
+        });
+        if (task.currentPhase) {
+            task.completedPhases.push(task.currentPhase);
+        }
+        const phaseEntry = state.phaseOrder.find((p) => p.taskType === task.taskType);
+        if (phaseEntry) {
+            const currentIdx = phaseEntry.phases.indexOf(task.currentPhase || "");
+            const nextPhase = phaseEntry.phases[currentIdx + 1];
+            if (nextPhase) {
+                task.currentPhase = nextPhase;
+                task.status = "PENDING";
+            }
+            else {
+                task.currentPhase = null;
+                task.status = "DONE";
+                state.completedCount = (state.completedCount || 0) + 1;
+                state.activeCount = Math.max(0, (state.activeCount || 0) - 1);
+            }
+        }
+        task.assignedTo = null;
+        task.updatedAt = action.input.updatedAt;
+        state.lastProcessedAt = action.input.updatedAt;
+    },
+    completeTaskOperation(state, action) {
+        const task = state.tasks.find((t) => t.id === action.input.taskId);
+        if (!task)
+            throw new TaskNotFoundError("Task not found");
+        task.status = "DONE";
+        task.currentPhase = null;
+        task.updatedAt = action.input.updatedAt;
+        state.completedCount = (state.completedCount || 0) + 1;
+        state.activeCount = Math.max(0, (state.activeCount || 0) - 1);
+        state.lastProcessedAt = action.input.updatedAt;
+    },
+    failTaskOperation(state, action) {
+        const task = state.tasks.find((t) => t.id === action.input.taskId);
+        if (!task)
+            throw new TaskNotFoundError("Task not found");
+        task.status = "FAILED";
+        task.updatedAt = action.input.updatedAt;
+        state.activeCount = Math.max(0, (state.activeCount || 0) - 1);
+        state.lastProcessedAt = action.input.updatedAt;
+    },
+    blockTaskOperation(state, action) {
+        const task = state.tasks.find((t) => t.id === action.input.taskId);
+        if (!task)
+            throw new TaskNotFoundError("Task not found");
+        task.status = "BLOCKED";
+        task.updatedAt = action.input.updatedAt;
+    },
+    unblockTaskOperation(state, action) {
+        const task = state.tasks.find((t) => t.id === action.input.taskId);
+        if (!task)
+            throw new TaskNotFoundError("Task not found");
+        if (task.status !== "BLOCKED")
+            throw new InvalidTaskStatusError("Task is not blocked");
+        task.status = "PENDING";
+        task.updatedAt = action.input.updatedAt;
+    },
+};

package/dist/document-models/pipeline-queue/v1/src/utils.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/document-models/pipeline-queue/v1/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../document-models/pipeline-queue/v1/src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC"}

package/dist/document-models/pipeline-queue/v1/src/utils.js

@@ -0,0 +1 @@
+export {};

package/dist/document-models/pipeline-queue/v1/tests/document-model.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+export {};
+//# sourceMappingURL=document-model.test.d.ts.map

package/dist/document-models/pipeline-queue/v1/tests/document-model.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-model.test.d.ts","sourceRoot":"","sources":["../../../../../document-models/pipeline-queue/v1/tests/document-model.test.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH;;;GAGG"}

package/dist/document-models/pipeline-queue/v1/tests/document-model.test.js

@@ -0,0 +1,104 @@
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+import { describe, it, expect } from "vitest";
+import { utils, initialGlobalState, initialLocalState, pipelineQueueDocumentType, isPipelineQueueDocument, assertIsPipelineQueueDocument, isPipelineQueueState, assertIsPipelineQueueState, } from "@powerhousedao/knowledge-note/document-models/pipeline-queue/v1";
+import { ZodError } from "zod";
+describe("PipelineQueue Document Model", () => {
+    it("should create a new PipelineQueue document", () => {
+        const document = utils.createDocument();
+        expect(document).toBeDefined();
+        expect(document.header.documentType).toBe(pipelineQueueDocumentType);
+    });
+    it("should create a new PipelineQueue document with a valid initial state", () => {
+        const document = utils.createDocument();
+        expect(document.state.global).toStrictEqual(initialGlobalState);
+        expect(document.state.local).toStrictEqual(initialLocalState);
+        expect(isPipelineQueueDocument(document)).toBe(true);
+        expect(isPipelineQueueState(document.state)).toBe(true);
+    });
+    it("should reject a document that is not a PipelineQueue document", () => {
+        const wrongDocumentType = utils.createDocument();
+        wrongDocumentType.header.documentType = "the-wrong-thing-1234";
+        try {
+            expect(assertIsPipelineQueueDocument(wrongDocumentType)).toThrow();
+            expect(isPipelineQueueDocument(wrongDocumentType)).toBe(false);
+        }
+        catch (error) {
+            expect(error).toBeInstanceOf(ZodError);
+        }
+    });
+    const wrongState = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    wrongState.state.global = {
+        ...{ notWhat: "you want" },
+    };
+    try {
+        expect(isPipelineQueueState(wrongState.state)).toBe(false);
+        expect(assertIsPipelineQueueState(wrongState.state)).toThrow();
+        expect(isPipelineQueueDocument(wrongState)).toBe(false);
+        expect(assertIsPipelineQueueDocument(wrongState)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const wrongInitialState = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    wrongInitialState.initialState.global = {
+        ...{ notWhat: "you want" },
+    };
+    try {
+        expect(isPipelineQueueState(wrongInitialState.state)).toBe(false);
+        expect(assertIsPipelineQueueState(wrongInitialState.state)).toThrow();
+        expect(isPipelineQueueDocument(wrongInitialState)).toBe(false);
+        expect(assertIsPipelineQueueDocument(wrongInitialState)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingIdInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingIdInHeader.header.id;
+    try {
+        expect(isPipelineQueueDocument(missingIdInHeader)).toBe(false);
+        expect(assertIsPipelineQueueDocument(missingIdInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingNameInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingNameInHeader.header.name;
+    try {
+        expect(isPipelineQueueDocument(missingNameInHeader)).toBe(false);
+        expect(assertIsPipelineQueueDocument(missingNameInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingCreatedAtUtcIsoInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingCreatedAtUtcIsoInHeader.header.createdAtUtcIso;
+    try {
+        expect(isPipelineQueueDocument(missingCreatedAtUtcIsoInHeader)).toBe(false);
+        expect(assertIsPipelineQueueDocument(missingCreatedAtUtcIsoInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+    const missingLastModifiedAtUtcIsoInHeader = utils.createDocument();
+    // @ts-expect-error - we are testing the error case
+    delete missingLastModifiedAtUtcIsoInHeader.header.lastModifiedAtUtcIso;
+    try {
+        expect(isPipelineQueueDocument(missingLastModifiedAtUtcIsoInHeader)).toBe(false);
+        expect(assertIsPipelineQueueDocument(missingLastModifiedAtUtcIsoInHeader)).toThrow();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(ZodError);
+    }
+});

package/dist/document-models/pipeline-queue/v1/tests/queue-management.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=queue-management.test.d.ts.map

package/dist/document-models/pipeline-queue/v1/tests/queue-management.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-management.test.d.ts","sourceRoot":"","sources":["../../../../../document-models/pipeline-queue/v1/tests/queue-management.test.ts"],"names":[],"mappings":""}