project-mgr 0.1.6 → 0.2.0

package/test/core.test.ts

@@ -9,13 +9,17 @@ import { run } from "../src/cli.js";
 import {
   addStatus,
   at,
+  countEntries,
   current,
   databasePath,
   history,
   importStatuses,
+  listProjects,
   openLedger,
   parseTime,
+  setProjectMetadata,
   toPortableStatusEntry,
+  validateProjectMetadataInput,
   validateStatusEntry,
   ValidationError,
 } from "../src/index.js";
@@ -55,6 +59,29 @@ test("domain normalizes valid values and rejects invalid input", () => {
       externalRef: "ref",
     },
   );
+  assert.equal(
+    validateStatusEntry({
+      project: "default-status",
+      summary: "sum",
+    }).status,
+    "completed",
+  );
+  assert.equal(
+    validateStatusEntry({
+      project: "done-status",
+      status: "done",
+      summary: "sum",
+    }).status,
+    "completed",
+  );
+  assert.ok(
+    validateStatusEntry({
+      project: "default-time",
+      status: "active",
+      summary: "sum",
+    }).occurredAt,
+  );
+
   for (const invalid of [
     null,
     [],
@@ -79,12 +106,59 @@ test("domain normalizes valid values and rejects invalid input", () => {
   });
   assert.equal("id" in portable, false);
   assert.equal("recordedAt" in portable, false);
+
+  assert.deepEqual(
+    validateProjectMetadataInput({
+      project: " demo ",
+      displayName: " Demo Project ",
+      description: " Desc ",
+      notes: " Notes ",
+    }),
+    {
+      project: "demo",
+      displayName: "Demo Project",
+      description: "Desc",
+      notes: "Notes",
+    },
+  );
+
+  assert.deepEqual(
+    validateProjectMetadataInput({
+      project: "demo",
+      description: null,
+      notes: "",
+    }),
+    {
+      project: "demo",
+      description: null,
+      notes: null,
+    },
+  );
+
+  for (const invalid of [
+    null,
+    [],
+    { unknownKey: true },
+    { project: "bad space" },
+    { project: "demo", description: 123 },
+    { project: "demo", notes: "x".repeat(2_001) },
+  ]) {
+    assert.throws(() => validateProjectMetadataInput(invalid), ValidationError);
+  }
 });
 
 test("SQLite ledger migrates, appends, is idempotent, and queries by timeline", () => {
   const db = openLedger(":memory:");
-  const first = addStatus(db, entry({ externalRef: "one", progress: "done" }));
+  const first = addStatus(
+    db,
+    entry({
+      externalRef: "one",
+      progress: "done",
+    }),
+  );
   assert.equal(first.inserted, true);
+  assert.equal(first.entry.progress, "done");
+
   assert.equal(
     addStatus(db, entry({ summary: "ignored", externalRef: "one" })).inserted,
     false,
@@ -137,8 +211,87 @@ test("SQLite ledger migrates, appends, is idempotent, and queries by timeline",
         count: number;
       }
     ).count,
-    1,
+    2,
+  );
+
+  // Test setProjectMetadata & listProjects
+  const meta = setProjectMetadata(db, {
+    project: "project-mgr",
+    displayName: "Project Manager",
+    description: "Updated Description",
+    notes: "Updated Notes",
+  });
+  assert.equal(meta.displayName, "Project Manager");
+  assert.equal(meta.description, "Updated Description");
+  assert.equal(meta.notes, "Updated Notes");
+
+  // Create project with notes only (no description)
+
+  const notesOnlyMeta = setProjectMetadata(db, {
+    project: "notes-only-meta",
+    notes: "Only Note",
+  });
+  assert.equal(notesOnlyMeta.description, undefined);
+  assert.equal(notesOnlyMeta.notes, "Only Note");
+
+  // Create project without status entries
+  setProjectMetadata(db, {
+    project: "standalone",
+    description: "Standalone App",
+  });
+
+  // Create project with tag for search
+  addStatus(
+    db,
+    entry({ project: "tag-proj", tags: ["nomatch", "my-special-tag"] }),
+  );
+  // Add projects with identical timestamps to exercise fallback tie-breaker
+  addStatus(
+    db,
+    entry({ project: "twin-a", occurredAt: "2026-05-01T00:00:00.000Z" }),
+  );
+  addStatus(
+    db,
+    entry({ project: "twin-b", occurredAt: "2026-05-01T00:00:00.000Z" }),
   );
+  // Add a project with an even newer status entry timestamp to test descending sort
+  addStatus(
+    db,
+    entry({ project: "newest-proj", occurredAt: "2026-12-31T00:00:00.000Z" }),
+  );
+  // Add project with undefined progress for query filtering test
+  addStatus(db, {
+    project: "no-progress-proj",
+    summary: "no progress summary",
+  });
+  const matchedNoProg = listProjects(db, { query: "no progress summary" });
+  assert.equal(matchedNoProg.length, 1);
+  const noMatch = listProjects(db, { query: "non-existent-tag-query" });
+  assert.equal(noMatch.length, 0);
+
+  const matchedNotes = listProjects(db, { query: "Updated Notes" });
+  assert.equal(matchedNotes.length, 1);
+  assert.equal(matchedNotes[0].project, "project-mgr");
+
+  const matchedStandalone = listProjects(db, { query: "Standalone App" });
+  assert.equal(matchedStandalone.length, 1);
+  assert.equal(matchedStandalone[0].project, "standalone");
+
+  const matchedNone = listProjects(db, { query: "nonexistent" });
+  assert.equal(matchedNone.length, 0);
+
+  assert.equal(countEntries(db) > 0, true);
+  assert.equal(countEntries(db, "tag-proj"), 1);
+
+  // Test clearing description and notes with null or empty string
+  const clearedMeta = setProjectMetadata(db, {
+    project: "project-mgr",
+    description: null,
+    notes: "",
+  });
+  assert.equal(clearedMeta.description, undefined);
+  assert.equal(clearedMeta.notes, undefined);
+
   db.close();
 });
 
@@ -209,7 +362,7 @@ test("CLI runs through a package-style symlink", () => {
   rmSync(directory, { recursive: true, force: true });
 });
 
-test("CLI supports add, import, reads, errors, and export formats", () => {
+test("CLI supports add, import, reads, errors, project metadata, and export formats", () => {
   const directory = mkdtempSync(join(tmpdir(), "pmgr-cli-"));
   const file = join(directory, "ledger.sqlite");
   const importFile = join(directory, "entries.jsonl");
@@ -253,6 +406,10 @@ test("CLI supports add, import, reads, errors, and export formats", () => {
       "active",
       "--summary",
       "added",
+      "--description",
+      "CLI project description",
+      "--notes",
+      "CLI project notes",
       "--progress",
       "covered",
       "--next",
@@ -263,10 +420,118 @@ test("CLI supports add, import, reads, errors, and export formats", () => {
       "cli",
       "--external-ref",
       "cli-add",
+      "--at",
+      timestamp,
       "--json",
     ]),
   );
   assert.equal(added.project, "cli");
+
+  // CLI set-project, projects, and list commands
+  assert.match(
+    execute([
+      "set-project",
+      "--project",
+      "custom-proj",
+      "--display-name",
+      "Custom Proj",
+      "--description",
+      "Custom description",
+      "--notes",
+      "Custom note",
+      "--json",
+    ]),
+    /Custom Proj/,
+  );
+
+  // Test set-project updates existing project with partial fields
+  assert.match(
+    execute([
+      "set-project",
+      "--project",
+      "custom-proj",
+      "--display-name",
+      "Custom Proj Renamed",
+    ]),
+    /Custom Proj Renamed/,
+  );
+  execute([
+    "set-project",
+    "--project",
+    "custom-proj",
+    "--description",
+    "Updated desc only",
+  ]);
+  execute([
+    "set-project",
+    "--project",
+    "custom-proj",
+    "--notes",
+    "Updated note only",
+  ]);
+  execute(["set-project", "--project", "custom-proj"]);
+
+  // Test list / projects fuzzy search across all branches and human formatting
+  assert.match(execute(["projects"]), /cli\tcli/);
+  assert.match(execute(["projects"]), /Description: CLI project description/);
+  assert.match(execute(["projects"]), /Notes: CLI project notes/);
+  assert.match(execute(["projects"]), /Latest Status: \(none\)/);
+
+  assert.match(
+    execute(["list", "--query", "Custom Proj Renamed"]),
+    /Custom Proj Renamed/,
+  );
+  assert.match(
+    execute(["list", "--query", "Updated desc only"]),
+    /Updated desc only/,
+  );
+  assert.match(
+    execute(["list", "--query", "Updated note only"]),
+    /Updated note only/,
+  );
+  assert.match(execute(["projects", "--query", "active"]), /cli/);
+  assert.match(execute(["projects", "--query", "added"]), /cli/);
+  assert.match(execute(["projects", "--query", "covered"]), /cli/);
+  assert.match(execute(["projects", "--query", "cli"]), /cli/);
+  assert.equal(
+    execute(["projects", "--query", "no-match"]),
+    "No projects found.\n",
+  );
+  assert.equal(execute(["projects", "--query", "no-match", "--json"]), "[]\n");
+
+  // Test clearing description and notes via CLI flags
+  assert.throws(
+    () =>
+      execute([
+        "set-project",
+        "--project",
+        "custom-proj",
+        "--description",
+        "desc",
+        "--clear-description",
+      ]),
+    /cannot specify both --description and --clear-description/,
+  );
+  assert.throws(
+    () =>
+      execute([
+        "set-project",
+        "--project",
+        "custom-proj",
+        "--notes",
+        "note",
+        "--clear-notes",
+      ]),
+    /cannot specify both --notes and --clear-notes/,
+  );
+  execute([
+    "set-project",
+    "--project",
+    "custom-proj",
+    "--clear-description",
+    "--clear-notes",
+  ]);
+
   assert.match(
     execute([
       "status",
@@ -277,6 +542,8 @@ test("CLI supports add, import, reads, errors, and export formats", () => {
       "active",
       "--summary",
       "human output",
+      "--at",
+      timestamp,
     ]),
     /human output/,
   );
@@ -318,8 +585,9 @@ test("CLI supports add, import, reads, errors, and export formats", () => {
     JSON.parse(execute(["history", "--limit", "2", "--json"])).map(
       (item: { project: string }) => item.project,
     ),
-    ["human", "cli"],
+    ["array", "json"],
   );
+
   assert.equal(
     JSON.parse(
       execute([
@@ -372,7 +640,9 @@ test("CLI supports add, import, reads, errors, and export formats", () => {
     () => execute(["status", "history", "--project", "cli", "--limit", "1.5"]),
     ValidationError,
   );
+  assert.throws(() => execute(["set-project"]), ValidationError);
   assert.throws(() => execute(["status", "add", "--project"]), ValidationError);
+
   assert.throws(
     () =>
       execute(["status", "current", "--project", "cli", "--project", "again"]),

package/test/server.test.ts

@@ -0,0 +1,354 @@
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { mkdtempSync, rmSync } from "node:fs";
+import { type IncomingMessage, type ServerResponse } from "node:http";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import {
+  addStatus,
+  getWebUIHTML,
+  handleRequest,
+  openBrowser,
+  openLedger,
+  run,
+  setProjectMetadata,
+  startServer,
+} from "../src/index.js";
+
+type MockResponse = {
+  statusCode: number;
+  headers: Record<string, string>;
+  body: string;
+  json: () => unknown;
+};
+
+function simulateRequest(
+  db: ReturnType<typeof openLedger>,
+  method: string,
+  url?: string,
+  hostHeader?: string,
+): MockResponse {
+  const req = new EventEmitter() as unknown as IncomingMessage;
+  req.method = method;
+  req.url = url as string;
+  req.headers = hostHeader ? { host: hostHeader } : {};
+
+  let statusCode = 200;
+  let headers: Record<string, string> = {};
+  let body = "";
+
+  const res = {
+    writeHead(code: number, hdrs: Record<string, string>) {
+      statusCode = code;
+      headers = hdrs;
+    },
+    end(data?: string) {
+      if (data) body += data;
+    },
+  } as unknown as ServerResponse;
+
+  handleRequest(req, res, db);
+
+  return {
+    statusCode,
+    headers,
+    body,
+    json: () => (body ? JSON.parse(body) : null),
+  };
+}
+
+test("server handles Web UI and REST API request routing", () => {
+  const db = openLedger(":memory:");
+  setProjectMetadata(db, {
+    project: "alpha",
+    displayName: "Alpha Project",
+    description: "Alpha description",
+    notes: "Alpha note",
+  });
+  addStatus(db, {
+    project: "alpha",
+    status: "active",
+    summary: "Alpha started",
+    progress: "50%",
+    blockers: ["B1"],
+    nextSteps: ["N1"],
+    decisions: ["D1"],
+    tags: ["t1"],
+  });
+
+  setProjectMetadata(db, {
+    project: "beta",
+    displayName: "Beta Project",
+  });
+
+  // Test GET / with empty/undefined url and host header
+  const rootRes = simulateRequest(db, "GET", "", "customhost:8080");
+  assert.equal(rootRes.statusCode, 200);
+  assert.equal(rootRes.headers["Content-Type"], "text/html; charset=utf-8");
+  assert.ok(rootRes.body.includes("Project Manager"));
+
+  // Test GET /index.html
+  const indexRes = simulateRequest(db, "GET", "/index.html");
+  assert.equal(indexRes.statusCode, 200);
+
+  // Test GET /api/projects
+  const projectsRes = simulateRequest(db, "GET", "/api/projects");
+  assert.equal(projectsRes.statusCode, 200);
+  assert.equal((projectsRes.json() as unknown[]).length, 2);
+
+  // Test GET /api/projects?query=alpha
+  const queryRes = simulateRequest(db, "GET", "/api/projects?query=alpha");
+  assert.equal(queryRes.statusCode, 200);
+  assert.equal((queryRes.json() as unknown[]).length, 1);
+
+  // Test GET /api/projects/:slug (found)
+  const projAlphaRes = simulateRequest(db, "GET", "/api/projects/alpha");
+  assert.equal(projAlphaRes.statusCode, 200);
+  assert.equal((projAlphaRes.json() as { project: string }).project, "alpha");
+
+  // Test GET /api/projects/:slug (not found)
+  const proj404Res = simulateRequest(db, "GET", "/api/projects/nonexistent");
+  assert.equal(proj404Res.statusCode, 404);
+  assert.equal(
+    (proj404Res.json() as { error: string }).error,
+    "Project not found",
+  );
+
+  // Test GET /api/history without query params
+  const defaultHistoryRes = simulateRequest(db, "GET", "/api/history");
+  assert.equal(defaultHistoryRes.statusCode, 200);
+
+  // Test GET /api/history with valid numeric limit and offset
+  const historyRes = simulateRequest(
+    db,
+    "GET",
+    "/api/history?project=alpha&limit=10&offset=5",
+  );
+  assert.equal(historyRes.statusCode, 200);
+
+  // Test GET /api/history with fallback limit/offset NaN
+  const historyFallbackRes = simulateRequest(
+    db,
+    "GET",
+    "/api/history?limit=invalid&offset=invalid",
+  );
+  assert.equal(historyFallbackRes.statusCode, 200);
+
+  // Test GET /api/stats
+  const statsRes = simulateRequest(db, "GET", "/api/stats");
+  assert.equal(statsRes.statusCode, 200);
+  const stats = statsRes.json() as {
+    totalProjects: number;
+    totalEntries: number;
+    statusCounts: Record<string, number>;
+  };
+  assert.equal(stats.totalProjects, 2);
+  assert.equal(stats.totalEntries, 1);
+  assert.equal(stats.statusCounts.active, 1);
+  assert.equal(stats.statusCounts.none, 1);
+
+  // Test 404 for unknown route
+  const notFoundRes = simulateRequest(db, "GET", "/api/unknown");
+  assert.equal(notFoundRes.statusCode, 404);
+
+  // Test 405 Method Not Allowed
+  const postRes = simulateRequest(db, "POST", "/api/projects");
+  assert.equal(postRes.statusCode, 405);
+
+  db.close();
+});
+
+test("startServer initializes HTTP server, closes clean, and handles 500 error boundary", async () => {
+  const directory = mkdtempSync(join(tmpdir(), "pmgr-server-"));
+  const dbFile = join(directory, "test-server.sqlite");
+  const previousDb = process.env.PMGR_DB_PATH;
+  const previousPort = process.env.PORT;
+  process.env.PMGR_DB_PATH = dbFile;
+  process.env.PORT = "0";
+
+  // Test startServer with custom host and PORT env
+  const serverWithHost = await startServer({ host: "localhost", open: false });
+  assert.equal(serverWithHost.host, "localhost");
+  await serverWithHost.close();
+
+  delete process.env.PORT;
+  const userDb = openLedger(":memory:");
+  const serverWithDb = await startServer({ port: 0, open: false, db: userDb });
+  assert.ok(serverWithDb.url.length > 0);
+  await serverWithDb.close();
+  userDb.close();
+
+  // Test startServer with default options (options = undefined / empty)
+  const defaultServerInst = await startServer({ port: 0 });
+  assert.ok(defaultServerInst.url.length > 0);
+  await defaultServerInst.close();
+
+  const serverInst = await startServer({ port: 0, open: false });
+  assert.ok(serverInst.url.length > 0);
+  assert.equal(serverInst.host, "127.0.0.1");
+
+  // Test createServer callback event firing
+  const req = new EventEmitter() as unknown as IncomingMessage;
+  req.method = "GET";
+  req.url = "/api/projects";
+  req.headers = { host: "localhost" };
+
+  let statusCode = 0;
+  let responseData = "";
+  const res = {
+    writeHead(code: number) {
+      statusCode = code;
+    },
+    end(data?: string) {
+      if (data) responseData += data;
+    },
+  } as unknown as ServerResponse;
+
+  serverInst.server.emit("request", req, res);
+  assert.equal(statusCode, 200);
+  assert.ok(responseData.includes("[]"));
+
+  // Test 500 error catch block in createServer handler for Error and non-Error
+  const brokenDbError = {
+    prepare() {
+      throw new Error("Simulated DB Failure");
+    },
+  } as unknown as ReturnType<typeof openLedger>;
+
+  const brokenDbString = {
+    prepare() {
+      throw "String Exception";
+    },
+  } as unknown as ReturnType<typeof openLedger>;
+
+  let errCode = 0;
+  let errData = "";
+  const errRes = {
+    writeHead(code: number) {
+      errCode = code;
+    },
+    end(data?: string) {
+      if (data) errData += data;
+    },
+  } as unknown as ServerResponse;
+
+  const brokenServerInst = await startServer({
+    port: 0,
+    open: false,
+    db: brokenDbError,
+  });
+  brokenServerInst.server.emit("request", req, errRes);
+  assert.equal(errCode, 500);
+  assert.ok(errData.includes("Simulated DB Failure"));
+  await brokenServerInst.close();
+
+  let stringErrCode = 0;
+  let stringErrData = "";
+  const stringErrRes = {
+    writeHead(code: number) {
+      stringErrCode = code;
+    },
+    end(data?: string) {
+      if (data) stringErrData += data;
+    },
+  } as unknown as ServerResponse;
+
+  const stringBrokenServerInst = await startServer({
+    port: 0,
+    open: false,
+    db: brokenDbString,
+  });
+  stringBrokenServerInst.server.emit("request", req, stringErrRes);
+  assert.equal(stringErrCode, 500);
+  assert.ok(stringErrData.includes("String Exception"));
+  await stringBrokenServerInst.close();
+
+  // Test address non-object null and string fallback in server listen callback
+  const mockServerInst = await startServer({ port: 0, open: false });
+  mockServerInst.server.address = () => null;
+  await mockServerInst.close();
+
+  const mockServerInst2 = await startServer({ port: 0, open: false });
+  mockServerInst2.server.address = () => "pipe-address";
+  await mockServerInst2.close();
+
+  // Test close error callback rejection (double close)
+  await serverInst.close();
+  await assert.rejects(async () => {
+    await serverInst.close();
+  });
+
+  if (previousDb) process.env.PMGR_DB_PATH = previousDb;
+  else delete process.env.PMGR_DB_PATH;
+  if (previousPort) process.env.PORT = previousPort;
+  else delete process.env.PORT;
+
+  rmSync(directory, { recursive: true, force: true });
+});
+
+test("openBrowser executes without throwing on all platforms", () => {
+  const originalPlatform = Object.getOwnPropertyDescriptor(process, "platform");
+  try {
+    Object.defineProperty(process, "platform", { value: "darwin" });
+    openBrowser("http://localhost:3000");
+
+    Object.defineProperty(process, "platform", { value: "win32" });
+    openBrowser("http://localhost:3000");
+
+    Object.defineProperty(process, "platform", { value: "linux" });
+    openBrowser("http://localhost:3000");
+  } finally {
+    if (originalPlatform) {
+      Object.defineProperty(process, "platform", originalPlatform);
+    }
+  }
+});
+
+test("CLI serve command supports port, host, no-open, and json output", async () => {
+  const directory = mkdtempSync(join(tmpdir(), "pmgr-cli-serve-"));
+  const dbFile = join(directory, "serve.sqlite");
+  const previousDb = process.env.PMGR_DB_PATH;
+  process.env.PMGR_DB_PATH = dbFile;
+
+  let outputText = "";
+  const write = (str: string) => {
+    outputText += str;
+  };
+
+  const instance = (await run(
+    ["serve", "--port", "0", "--host", "127.0.0.1", "--no-open", "--json"],
+    write,
+  )) as Awaited<ReturnType<typeof startServer>>;
+
+  assert.ok(outputText.includes('"url"'));
+  assert.ok(instance && typeof instance.close === "function");
+  await instance.close();
+
+  outputText = "";
+  const instance2 = (await run(
+    ["status", "serve", "--port", "0", "--open"],
+    write,
+  )) as Awaited<ReturnType<typeof startServer>>;
+  assert.ok(outputText.includes("Server running at"));
+  await instance2.close();
+
+  outputText = "";
+  process.env.PORT = "0";
+  const instance3 = (await run(["serve"], write)) as Awaited<
+    ReturnType<typeof startServer>
+  >;
+  assert.ok(outputText.includes("Server running at"));
+  await instance3.close();
+  delete process.env.PORT;
+
+  if (previousDb) process.env.PMGR_DB_PATH = previousDb;
+  else delete process.env.PMGR_DB_PATH;
+  rmSync(directory, { recursive: true, force: true });
+});
+
+test("getWebUIHTML returns HTML string", () => {
+  const html = getWebUIHTML();
+  assert.ok(typeof html === "string");
+  assert.ok(html.includes("<!DOCTYPE html>"));
+});