project-mgr 0.1.6 → 0.2.0

package/dist/domain.js

@@ -21,6 +21,12 @@ const keys = new Set([
     "source",
     "externalRef",
 ]);
+const projectMetadataKeys = new Set([
+    "project",
+    "displayName",
+    "description",
+    "notes",
+]);
 const projectName = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 export class ValidationError extends Error {
     constructor(message) {
@@ -38,6 +44,20 @@ function text(value, field, required = false) {
         throw new ValidationError(`${field} must be at most 2000 characters`);
     return normalized;
 }
+function nullableText(value, field) {
+    if (value === undefined)
+        return undefined;
+    if (value === null)
+        return null;
+    if (typeof value !== "string")
+        throw new ValidationError(`${field} must be a string or null`);
+    const normalized = value.trim();
+    if (normalized === "")
+        return null;
+    if (normalized.length > 2_000)
+        throw new ValidationError(`${field} must be at most 2000 characters`);
+    return normalized;
+}
 function textList(value, field) {
     if (value === undefined)
         return [];
@@ -53,6 +73,26 @@ export function parseTime(value, field) {
     }
     return new Date(value).toISOString();
 }
+export function validateProjectMetadataInput(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new ValidationError("project metadata must be an object");
+    const input = value;
+    for (const key of Object.keys(input))
+        if (!projectMetadataKeys.has(key))
+            throw new ValidationError(`unknown field: ${key}`);
+    const project = text(input.project, "project", true);
+    if (!projectName.test(project))
+        throw new ValidationError("project must use letters, numbers, dots, underscores, or hyphens");
+    const displayName = text(input.displayName, "displayName");
+    const description = nullableText(input.description, "description");
+    const notes = nullableText(input.notes, "notes");
+    return {
+        project,
+        ...(displayName !== undefined ? { displayName } : {}),
+        ...(description !== undefined ? { description } : {}),
+        ...(notes !== undefined ? { notes } : {}),
+    };
+}
 export function validateStatusEntry(value, defaultSource = "human") {
     if (!value || typeof value !== "object" || Array.isArray(value))
         throw new ValidationError("entry must be an object");
@@ -63,7 +103,15 @@ export function validateStatusEntry(value, defaultSource = "human") {
     const project = text(input.project, "project", true);
     if (!projectName.test(project))
         throw new ValidationError("project must use letters, numbers, dots, underscores, or hyphens");
-    if (!statuses.includes(input.status))
+    let statusInput = input.status;
+    if (statusInput === undefined || statusInput === null) {
+        statusInput = "completed";
+    }
+    else if (typeof statusInput === "string" &&
+        statusInput.trim().toLowerCase() === "done") {
+        statusInput = "completed";
+    }
+    if (!statuses.includes(statusInput))
         throw new ValidationError("status is invalid");
     const source = input.source === undefined ? defaultSource : input.source;
     if (!sources.includes(source))
@@ -73,7 +121,7 @@ export function validateStatusEntry(value, defaultSource = "human") {
         throw new ValidationError("externalRef must be at most 200 characters");
     return {
         project,
-        status: input.status,
+        status: statusInput,
         summary: text(input.summary, "summary", true),
         progress: text(input.progress, "progress"),
         blockers: textList(input.blockers, "blockers"),
@@ -88,19 +136,20 @@ export function validateStatusEntry(value, defaultSource = "human") {
     };
 }
 export function toPortableStatusEntry(entry) {
-    return {
+    const result = {
         project: entry.project,
         status: entry.status,
         summary: entry.summary,
-        ...(entry.progress === undefined ? {} : { progress: entry.progress }),
         blockers: entry.blockers,
         nextSteps: entry.nextSteps,
         decisions: entry.decisions,
         tags: entry.tags,
         occurredAt: entry.occurredAt,
         source: entry.source,
-        ...(entry.externalRef === undefined
-            ? {}
-            : { externalRef: entry.externalRef }),
     };
+    if (entry.progress !== undefined)
+        result.progress = entry.progress;
+    if (entry.externalRef !== undefined)
+        result.externalRef = entry.externalRef;
+    return result;
 }

package/dist/index.d.ts

@@ -1,2 +1,5 @@
+export * from "./cli.js";
 export * from "./db.js";
 export * from "./domain.js";
+export * from "./server.js";
+export * from "./web/ui.js";

package/dist/index.js

@@ -1,2 +1,5 @@
+export * from "./cli.js";
 export * from "./db.js";
 export * from "./domain.js";
+export * from "./server.js";
+export * from "./web/ui.js";

package/dist/server.d.ts

@@ -0,0 +1,18 @@
+import { type IncomingMessage, type Server, type ServerResponse } from "node:http";
+import { type Ledger } from "./db.js";
+export type ServerOptions = {
+    port?: number;
+    host?: string;
+    open?: boolean;
+    db?: Ledger;
+};
+export type ServerInstance = {
+    server: Server;
+    url: string;
+    port: number;
+    host: string;
+    close: () => Promise<void>;
+};
+export declare function openBrowser(url: string): void;
+export declare function handleRequest(req: IncomingMessage, res: ServerResponse, db: Ledger): void;
+export declare function startServer(options?: ServerOptions): Promise<ServerInstance>;

package/dist/server.js

@@ -0,0 +1,147 @@
+import { exec } from "node:child_process";
+import { createServer, } from "node:http";
+import { URL } from "node:url";
+import { countEntries, history, listProjects, openLedger, } from "./db.js";
+import { getWebUIHTML } from "./web/ui.js";
+export function openBrowser(url) {
+    const platform = process.platform;
+    let command = "";
+    if (platform === "darwin") {
+        command = `open "${url}"`;
+    }
+    else if (platform === "win32") {
+        command = `start "" "${url}"`;
+    }
+    else {
+        command = `xdg-open "${url}"`;
+    }
+    exec(command, () => {
+        /* ignore background exec errors */
+    });
+}
+function parseQueryParams(url) {
+    const params = {};
+    for (const [key, value] of url.searchParams.entries()) {
+        params[key] = value;
+    }
+    return params;
+}
+function sendJson(res, statusCode, data) {
+    res.writeHead(statusCode, {
+        "Content-Type": "application/json; charset=utf-8",
+        "Cache-Control": "no-cache",
+    });
+    res.end(JSON.stringify(data));
+}
+export function handleRequest(req, res, db) {
+    if (req.method !== "GET" && req.method !== "HEAD") {
+        sendJson(res, 405, { error: "Method not allowed" });
+        return;
+    }
+    const reqUrl = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+    const pathname = reqUrl.pathname;
+    const query = parseQueryParams(reqUrl);
+    if (pathname === "/" || pathname === "/index.html") {
+        res.writeHead(200, {
+            "Content-Type": "text/html; charset=utf-8",
+            "Cache-Control": "no-cache",
+        });
+        res.end(getWebUIHTML());
+        return;
+    }
+    if (pathname === "/api/projects") {
+        const projects = listProjects(db, { query: query.query });
+        sendJson(res, 200, projects);
+        return;
+    }
+    if (pathname.startsWith("/api/projects/")) {
+        const slug = decodeURIComponent(pathname.slice("/api/projects/".length));
+        const projects = listProjects(db);
+        const target = projects.find((p) => p.project === slug);
+        if (!target) {
+            sendJson(res, 404, { error: "Project not found" });
+        }
+        else {
+            sendJson(res, 200, target);
+        }
+        return;
+    }
+    if (pathname === "/api/history") {
+        const project = query.project;
+        const since = query.since;
+        const until = query.until;
+        const rawLimit = Number(query.limit ?? 100);
+        const rawOffset = Number(query.offset ?? 0);
+        const entries = history(db, project, {
+            since,
+            until,
+            limit: Number.isInteger(rawLimit) && rawLimit >= 0 ? rawLimit : 100,
+            offset: Number.isInteger(rawOffset) && rawOffset >= 0 ? rawOffset : 0,
+        });
+        sendJson(res, 200, entries);
+        return;
+    }
+    if (pathname === "/api/stats") {
+        const projects = listProjects(db);
+        const totalEntries = countEntries(db);
+        const statusCounts = {};
+        for (const proj of projects) {
+            const st = proj.latestStatus?.status || "none";
+            statusCounts[st] = (statusCounts[st] || 0) + 1;
+        }
+        sendJson(res, 200, {
+            totalProjects: projects.length,
+            totalEntries,
+            statusCounts,
+        });
+        return;
+    }
+    sendJson(res, 404, { error: "Not found" });
+}
+export function startServer(options = {}) {
+    const host = options.host ?? "127.0.0.1";
+    const port = options.port ??
+        (process.env.PORT ? Number(process.env.PORT) : /* c8 ignore next */ 3000);
+    const db = options.db || openLedger();
+    const shouldOpen = options.open ?? true;
+    const server = createServer((req, res) => {
+        try {
+            handleRequest(req, res, db);
+        }
+        catch (err) {
+            sendJson(res, 500, {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    });
+    return new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, host, () => {
+            /* c8 ignore start -- server.address() ternary branch is Node network adapter glue */
+            const address = server.address();
+            const actualPort = typeof address === "object" && address !== null ? address.port : port;
+            /* c8 ignore stop */
+            const url = `http://${host}:${actualPort}`;
+            if (shouldOpen) {
+                openBrowser(url);
+            }
+            resolve({
+                server,
+                url,
+                port: actualPort,
+                host,
+                close: () => new Promise((resClose, rejClose) => {
+                    server.close((err) => {
+                        if (!options.db) {
+                            db.close();
+                        }
+                        if (err)
+                            rejClose(err);
+                        else
+                            resClose();
+                    });
+                }),
+            });
+        });
+    });
+}

package/dist/web/ui.d.ts

@@ -0,0 +1 @@
+export declare function getWebUIHTML(): string;