@plandesk/api 0.7.0 → 0.9.0

package/dist/serialize.d.ts

@@ -1,4 +1,4 @@
-import type { AgentRun, AgentRunEvent, Document, DocumentComment, Edge, Note, Project, Task, TaskStatus } from '@plandesk/db';
+import type { AgentRun, AgentRunEvent, Document, DocumentComment, Edge, Folder, Goal, Note, Project, Tag, Task, TaskStatus } from '@plandesk/db';
 export type PaginationParams = {
     limit?: number;
     offset?: number;
@@ -21,9 +21,39 @@ export declare function serializeProjectDetail(project: Project, summary: TaskSt
     created_at: string;
     updated_at: string;
 };
-export declare function serializeTask(task: Task): {
+export type SerializedTag = {
     id: string;
     project_id: string;
+    name: string;
+    color: string | null;
+    created_at: string;
+};
+export declare function serializeTag(tag: Tag): SerializedTag;
+export declare function serializeGoal(goal: Goal): {
+    id: string;
+    project_id: string;
+    objective: string;
+    status: "active" | "paused" | "complete" | "blocked";
+    verification_surface: string | null;
+    constraints: string | null;
+    boundaries: string | null;
+    iteration_policy: string | null;
+    stop_condition: string | null;
+    budget: string | null;
+    last_verification: {
+        at: string;
+        green: boolean;
+        kind: string | null;
+        detail?: string;
+    } | null;
+    created_at: string;
+    updated_at: string;
+};
+export declare function serializeTask(task: Task, tags?: Tag[]): {
+    tags?: SerializedTag[] | undefined;
+    id: string;
+    project_id: string;
+    goal_id: string;
     label: string;
     status: "scope" | "todo" | "in_progress" | "done" | "backlog";
     description: string | null;
@@ -41,6 +71,7 @@ export type SerializedDocument = {
     body: string | null;
     status_line: string | null;
     parent_id: string | null;
+    folder_id: string | null;
     linked_task_id: string | null;
     created_at: string;
     updated_at: string;
@@ -68,6 +99,24 @@ export type SerializedComment = {
 };
 export declare function serializeComment(comment: DocumentComment): SerializedComment;
 export declare function buildDocumentTree(documents: Document[]): SerializedDocumentTree[];
+export type SerializedFolder = {
+    id: string;
+    project_id: string;
+    name: string;
+    parent_folder_id: string | null;
+    created_at: string;
+    updated_at: string;
+};
+export declare function serializeFolder(folder: Folder): SerializedFolder;
+export type SerializedFolderTree = SerializedFolder & {
+    folders: SerializedFolderTree[];
+    documents: SerializedDocumentTree[];
+};
+export type SerializedDocumentFolderTree = {
+    folders: SerializedFolderTree[];
+    documents: SerializedDocumentTree[];
+};
+export declare function buildFolderTree(folders: Folder[], documents: Document[]): SerializedDocumentFolderTree;
 export declare function serializeEdge(edge: Edge): {
     id: string;
     project_id: string;

package/dist/serialize.js

@@ -36,10 +36,54 @@ export function serializeProjectDetail(project, summary) {
         summary,
     };
 }
-export function serializeTask(task) {
+export function serializeTag(tag) {
+    return {
+        id: tag.id,
+        project_id: tag.projectId,
+        name: tag.name,
+        color: tag.color,
+        created_at: tag.createdAt.toISOString(),
+    };
+}
+function parseLastVerification(raw) {
+    if (raw === null) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.at === 'string' &&
+            typeof parsed.green === 'boolean' &&
+            (parsed.kind === null || typeof parsed.kind === 'string')) {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function serializeGoal(goal) {
+    return {
+        id: goal.id,
+        project_id: goal.projectId,
+        objective: goal.objective,
+        status: goal.status,
+        verification_surface: goal.verificationSurface,
+        constraints: goal.constraints,
+        boundaries: goal.boundaries,
+        iteration_policy: goal.iterationPolicy,
+        stop_condition: goal.stopCondition,
+        budget: goal.budget,
+        last_verification: parseLastVerification(goal.lastVerification),
+        created_at: goal.createdAt.toISOString(),
+        updated_at: goal.updatedAt.toISOString(),
+    };
+}
+export function serializeTask(task, tags) {
     return {
         id: task.id,
         project_id: task.projectId,
+        goal_id: task.goalId,
         label: task.label,
         status: task.status,
         description: task.description,
@@ -49,6 +93,7 @@ export function serializeTask(task) {
         due_date: task.dueDate?.toISOString() ?? null,
         created_at: task.createdAt.toISOString(),
         updated_at: task.updatedAt.toISOString(),
+        ...(tags !== undefined ? { tags: tags.map(serializeTag) } : {}),
     };
 }
 export function serializeDocument(document) {
@@ -59,6 +104,7 @@ export function serializeDocument(document) {
         body: document.body,
         status_line: document.statusLine,
         parent_id: document.parentId,
+        folder_id: document.folderId,
         linked_task_id: document.linkedTaskId,
         created_at: document.createdAt.toISOString(),
         updated_at: document.updatedAt.toISOString(),
@@ -109,6 +155,60 @@ export function buildDocumentTree(documents) {
     }
     return roots;
 }
+export function serializeFolder(folder) {
+    return {
+        id: folder.id,
+        project_id: folder.projectId,
+        name: folder.name,
+        parent_folder_id: folder.parentFolderId,
+        created_at: folder.createdAt.toISOString(),
+        updated_at: folder.updatedAt.toISOString(),
+    };
+}
+export function buildFolderTree(folders, documents) {
+    const folderNodes = new Map();
+    for (const folder of folders) {
+        folderNodes.set(folder.id, { ...serializeFolder(folder), folders: [], documents: [] });
+    }
+    const rootFolders = [];
+    for (const folder of folders) {
+        const node = folderNodes.get(folder.id);
+        if (!node) {
+            continue;
+        }
+        const parent = folder.parentFolderId === null ? undefined : folderNodes.get(folder.parentFolderId);
+        if (parent) {
+            parent.folders.push(node);
+        }
+        else {
+            rootFolders.push(node);
+        }
+    }
+    const documentsByFolder = new Map();
+    for (const document of documents) {
+        const key = document.folderId !== null && folderNodes.has(document.folderId) ? document.folderId : null;
+        const group = documentsByFolder.get(key);
+        if (group) {
+            group.push(document);
+        }
+        else {
+            documentsByFolder.set(key, [document]);
+        }
+    }
+    for (const [folderId, group] of documentsByFolder) {
+        if (folderId === null) {
+            continue;
+        }
+        const node = folderNodes.get(folderId);
+        if (node) {
+            node.documents = buildDocumentTree(group);
+        }
+    }
+    return {
+        folders: rootFolders,
+        documents: buildDocumentTree(documentsByFolder.get(null) ?? []),
+    };
+}
 export function serializeEdge(edge) {
     return {
         id: edge.id,

package/dist/server.js

@@ -3,31 +3,39 @@ import { createAuthMiddleware } from './auth.js';
 import { healthRouter } from './routes/health.js';
 import { createProjectsRouter } from './routes/projects.js';
 import { createTasksRouter } from './routes/tasks.js';
+import { createTagsRouter } from './routes/tags.js';
 import { createCanvasRouter } from './routes/canvas.js';
 import { createCommentsRouter } from './routes/comments.js';
 import { createDocumentsRouter } from './routes/documents.js';
+import { createFoldersRouter } from './routes/folders.js';
 import { createNotesRouter } from './routes/notes.js';
 import { createEventsRouter } from './routes/events.js';
 import { createTokensRouter } from './routes/tokens.js';
 import { createAgentRunsRouter } from './routes/agent-runs.js';
+import { createGoalsRouter } from './routes/goals.js';
+import { createSubmissionsRouter } from './routes/submissions.js';
 import { mountStatic } from './static.js';
 import { createServices } from './services/index.js';
 export function createApp(deps) {
     const services = deps.services ?? createServices({ db: deps.db, eventBus: deps.eventBus });
-    const { eventBus, projectService, taskService, canvasService, documentService, noteService, commentService, agentRunService, tokenService, } = services;
+    const { eventBus, projectService, goalService, taskService, tagService, canvasService, documentService, folderService, noteService, commentService, agentRunService, tokenService, syncService, } = services;
     const app = new Hono();
     if (deps.authPassword !== undefined && deps.authPassword.length > 0) {
         app.use('*', createAuthMiddleware(deps.authPassword));
     }
     app.route('/api/v1', healthRouter);
     app.route('/api/v1', createProjectsRouter(projectService, taskService));
+    app.route('/api/v1', createGoalsRouter(goalService));
     app.route('/api/v1', createTasksRouter(taskService));
+    app.route('/api/v1', createTagsRouter(tagService));
     app.route('/api/v1', createCanvasRouter(canvasService));
     app.route('/api/v1', createDocumentsRouter(documentService));
+    app.route('/api/v1', createFoldersRouter(folderService));
     app.route('/api/v1', createNotesRouter(noteService));
     app.route('/api/v1', createCommentsRouter(commentService));
     app.route('/api/v1', createTokensRouter(tokenService));
     app.route('/api/v1', createAgentRunsRouter(agentRunService));
+    app.route('/api/v1', createSubmissionsRouter(syncService, projectService));
     app.route('/api/v1', createEventsRouter(eventBus));
     mountStatic(app);
     if (deps.mcp) {

package/dist/services/canvas.d.ts

@@ -30,8 +30,10 @@ export declare class InvalidCanvasError extends Error {
 export declare function createCanvasService(deps: CanvasServiceDeps): {
     get(projectId: string): {
         nodes: {
+            tags?: import("../serialize.js").SerializedTag[] | undefined;
             id: string;
             project_id: string;
+            goal_id: string;
             label: string;
             status: "scope" | "todo" | "in_progress" | "done" | "backlog";
             description: string | null;
@@ -71,8 +73,10 @@ export declare function createCanvasService(deps: CanvasServiceDeps): {
     } | undefined;
     putLayout(projectId: string, payload: PutCanvasLayoutInput): {
         nodes: {
+            tags?: import("../serialize.js").SerializedTag[] | undefined;
             id: string;
             project_id: string;
+            goal_id: string;
             label: string;
             status: "scope" | "todo" | "in_progress" | "done" | "backlog";
             description: string | null;

package/dist/services/canvas.js

@@ -1,4 +1,4 @@
-import { createEdge, createTask, deleteEdge as dbDeleteEdge, getEdgeByProjectAndId, getProject, getTask, listEdges, listTasks, updateEdge, updateProject, updateTask, } from '@plandesk/db';
+import { createEdge, createTask, getOrCreateDefaultGoal, deleteEdge as dbDeleteEdge, getEdgeByProjectAndId, getProject, getTask, listEdges, listTasks, updateEdge, updateProject, updateTask, } from '@plandesk/db';
 import { serializeEdge, serializeTask } from '../serialize.js';
 export class InvalidCanvasError extends Error {
     constructor(message) {
@@ -21,7 +21,7 @@ export function createCanvasService(deps) {
         const tasks = listTasks(db, projectId);
         const edgeRows = listEdges(db, projectId);
         return {
-            nodes: tasks.map(serializeTask),
+            nodes: tasks.map((task) => serializeTask(task)),
             edges: edgeRows.map(serializeEdge),
             layout: serializeLayout(project.canvasLayout),
         };
@@ -93,6 +93,7 @@ export function createCanvasService(deps) {
                     }
                     const created = createTask(tx, {
                         projectId,
+                        goalId: getOrCreateDefaultGoal(tx, projectId).id,
                         id: node.id,
                         label: node.label,
                         status: 'todo',

package/dist/services/documents.d.ts

@@ -1,5 +1,5 @@
 import { type Db } from '@plandesk/db';
-import { type PaginationParams, type SerializedDocument, type SerializedDocumentTree } from '../serialize.js';
+import { type PaginationParams, type SerializedDocument, type SerializedDocumentFolderTree, type SerializedDocumentTree } from '../serialize.js';
 import type { EventBus } from '../events.js';
 export type DocumentServiceDeps = {
     db: Db;
@@ -10,6 +10,7 @@ export type CreateDocumentInput = {
     body?: string | null;
     statusLine?: string | null;
     parentId?: string | null;
+    folderId?: string | null;
     linkedTaskId?: string | null;
 };
 export type UpdateDocumentInput = {
@@ -17,6 +18,7 @@ export type UpdateDocumentInput = {
     body?: string | null;
     statusLine?: string | null;
     parentId?: string | null;
+    folderId?: string | null;
     linkedTaskId?: string | null;
 };
 export declare class InvalidDocumentError extends Error {
@@ -24,6 +26,8 @@ export declare class InvalidDocumentError extends Error {
 }
 export declare function createDocumentService(deps: DocumentServiceDeps): {
     listTree(projectId: string, pagination?: PaginationParams): SerializedDocumentTree[] | undefined;
+    listFolderTree(projectId: string): SerializedDocumentFolderTree | undefined;
+    listByFolder(projectId: string, folderId: string): SerializedDocumentTree[] | undefined;
     create(projectId: string, input: CreateDocumentInput): SerializedDocument | undefined;
     get(id: string): SerializedDocument | undefined;
     update(id: string, input: UpdateDocumentInput): SerializedDocument | undefined;

package/dist/services/documents.js

@@ -1,5 +1,5 @@
-import { createDocument as dbCreateDocument, deleteCommentsByDocumentId, deleteDocument as dbDeleteDocument, detachDocumentChildren, getDocument as dbGetDocument, getDocumentByTask as dbGetDocumentByTask, getProject, getTask, listDocuments as dbListDocuments, updateDocument as dbUpdateDocument, } from '@plandesk/db';
-import { buildDocumentTree, serializeDocument, } from '../serialize.js';
+import { createDocument as dbCreateDocument, deleteCommentsByDocumentId, deleteDocument as dbDeleteDocument, detachDocumentChildren, getDocument as dbGetDocument, getDocumentByTask as dbGetDocumentByTask, getFolderByProjectAndId, getProject, getTask, listDocuments as dbListDocuments, listFolders as dbListFolders, updateDocument as dbUpdateDocument, } from '@plandesk/db';
+import { buildDocumentTree, buildFolderTree, serializeDocument, } from '../serialize.js';
 export class InvalidDocumentError extends Error {
     constructor(message) {
         super(message);
@@ -18,6 +18,11 @@ function assertParentInProject(db, projectId, parentId) {
         throw new InvalidDocumentError('Parent document does not belong to project');
     }
 }
+function assertFolderInProject(db, projectId, folderId) {
+    if (!getFolderByProjectAndId(db, projectId, folderId)) {
+        throw new InvalidDocumentError('Folder does not belong to project');
+    }
+}
 export function createDocumentService(deps) {
     const { db, eventBus } = deps;
     return {
@@ -28,6 +33,23 @@ export function createDocumentService(deps) {
             }
             return buildDocumentTree(dbListDocuments(db, projectId, pagination));
         },
+        listFolderTree(projectId) {
+            const project = getProject(db, projectId);
+            if (!project) {
+                return undefined;
+            }
+            return buildFolderTree(dbListFolders(db, projectId), dbListDocuments(db, projectId));
+        },
+        listByFolder(projectId, folderId) {
+            const project = getProject(db, projectId);
+            if (!project) {
+                return undefined;
+            }
+            if (!getFolderByProjectAndId(db, projectId, folderId)) {
+                return undefined;
+            }
+            return buildDocumentTree(dbListDocuments(db, projectId, { folderId }));
+        },
         create(projectId, input) {
             const project = getProject(db, projectId);
             if (!project) {
@@ -39,12 +61,16 @@ export function createDocumentService(deps) {
             if (input.parentId !== undefined && input.parentId !== null) {
                 assertParentInProject(db, projectId, input.parentId);
             }
+            if (input.folderId !== undefined && input.folderId !== null) {
+                assertFolderInProject(db, projectId, input.folderId);
+            }
             const document = dbCreateDocument(db, {
                 projectId,
                 title: input.title,
                 body: input.body,
                 statusLine: input.statusLine,
                 parentId: input.parentId,
+                folderId: input.folderId,
                 linkedTaskId: input.linkedTaskId,
             });
             eventBus.emit({
@@ -75,6 +101,9 @@ export function createDocumentService(deps) {
                 }
                 assertParentInProject(db, existing.projectId, input.parentId);
             }
+            if (input.folderId !== undefined && input.folderId !== null) {
+                assertFolderInProject(db, existing.projectId, input.folderId);
+            }
             const document = dbUpdateDocument(db, id, input);
             if (!document) {
                 return undefined;

package/dist/services/folders.d.ts

@@ -0,0 +1,27 @@
+import { type Db } from '@plandesk/db';
+import { type SerializedFolder } from '../serialize.js';
+import type { EventBus } from '../events.js';
+export type FolderServiceDeps = {
+    db: Db;
+    eventBus: EventBus;
+};
+export type CreateFolderInput = {
+    name: string;
+    parentFolderId?: string | null;
+};
+export type UpdateFolderInput = {
+    name?: string;
+    parentFolderId?: string | null;
+};
+export declare class InvalidFolderError extends Error {
+    constructor(message: string);
+}
+export declare function createFolderService(deps: FolderServiceDeps): {
+    list(projectId: string): SerializedFolder[] | undefined;
+    create(projectId: string, input: CreateFolderInput): SerializedFolder | undefined;
+    get(id: string): SerializedFolder | undefined;
+    update(id: string, input: UpdateFolderInput): SerializedFolder | undefined;
+    delete(id: string): boolean;
+};
+export type FolderService = ReturnType<typeof createFolderService>;
+//# sourceMappingURL=folders.d.ts.map

package/dist/services/folders.js

@@ -0,0 +1,107 @@
+import { createFolder as dbCreateFolder, deleteFolder as dbDeleteFolder, getFolder as dbGetFolder, getProject, listFolders as dbListFolders, moveDocumentsToFolder, reparentChildFolders, updateFolder as dbUpdateFolder, } from '@plandesk/db';
+import { serializeFolder } from '../serialize.js';
+export class InvalidFolderError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InvalidFolderError';
+    }
+}
+function assertNonEmptyName(name) {
+    if (name.trim() === '') {
+        throw new InvalidFolderError('Folder name must not be empty');
+    }
+}
+function assertParentInProject(db, projectId, parentFolderId) {
+    const parent = dbGetFolder(db, parentFolderId);
+    if (!parent || parent.projectId !== projectId) {
+        throw new InvalidFolderError('Parent folder does not belong to project');
+    }
+}
+function assertNoCycle(db, folderId, newParentFolderId) {
+    const visited = new Set();
+    let current = newParentFolderId;
+    while (current !== null) {
+        if (current === folderId) {
+            throw new InvalidFolderError('Re-parenting would create a folder cycle');
+        }
+        if (visited.has(current)) {
+            return;
+        }
+        visited.add(current);
+        current = dbGetFolder(db, current)?.parentFolderId ?? null;
+    }
+}
+export function createFolderService(deps) {
+    const { db, eventBus } = deps;
+    return {
+        list(projectId) {
+            const project = getProject(db, projectId);
+            if (!project) {
+                return undefined;
+            }
+            return dbListFolders(db, projectId).map(serializeFolder);
+        },
+        create(projectId, input) {
+            const project = getProject(db, projectId);
+            if (!project) {
+                return undefined;
+            }
+            assertNonEmptyName(input.name);
+            if (input.parentFolderId !== undefined && input.parentFolderId !== null) {
+                assertParentInProject(db, projectId, input.parentFolderId);
+            }
+            const folder = dbCreateFolder(db, {
+                projectId,
+                name: input.name,
+                parentFolderId: input.parentFolderId,
+            });
+            eventBus.emit({ type: 'folder_created', folderId: folder.id, projectId });
+            return serializeFolder(folder);
+        },
+        get(id) {
+            const folder = dbGetFolder(db, id);
+            if (!folder) {
+                return undefined;
+            }
+            return serializeFolder(folder);
+        },
+        update(id, input) {
+            const existing = dbGetFolder(db, id);
+            if (!existing) {
+                return undefined;
+            }
+            if (input.name !== undefined) {
+                assertNonEmptyName(input.name);
+            }
+            if (input.parentFolderId !== undefined && input.parentFolderId !== null) {
+                if (input.parentFolderId === id) {
+                    throw new InvalidFolderError('Folder cannot be its own parent');
+                }
+                assertParentInProject(db, existing.projectId, input.parentFolderId);
+                assertNoCycle(db, id, input.parentFolderId);
+            }
+            const folder = dbUpdateFolder(db, id, input);
+            if (!folder) {
+                return undefined;
+            }
+            eventBus.emit({ type: 'folder_updated', folderId: folder.id, projectId: folder.projectId });
+            return serializeFolder(folder);
+        },
+        delete(id) {
+            const existing = dbGetFolder(db, id);
+            if (!existing) {
+                return false;
+            }
+            // Never orphan: children folders and contained documents move to the
+            // deleted folder's parent (or root when the folder was at root).
+            db.transaction((tx) => {
+                reparentChildFolders(tx, id, existing.parentFolderId);
+                moveDocumentsToFolder(tx, id, existing.parentFolderId);
+                dbDeleteFolder(tx, id);
+            });
+            eventBus.emit({ type: 'folder_updated', folderId: id, projectId: existing.projectId });
+            return true;
+        },
+    };
+}
+//# sourceMappingURL=folders.js.map