pi-task-manager 0.1.0

package/tests/task-manager.test.ts

@@ -0,0 +1,158 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { TaskManager } from "../lib/task-manager.ts";
+
+function setup() {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "tm-test-"));
+	const tm = new TaskManager();
+	tm.openFile(dir);
+	return { tm, dir };
+}
+
+const id = (r: Record<string, unknown>) => r.task_id as string;
+
+test("open creates TODO.md", () => {
+	const { tm, dir } = setup();
+	assert.ok(fs.existsSync(path.join(dir, "TODO.md")));
+	assert.equal(tm.isOpen, true);
+	tm.closeFile();
+});
+
+test("add: hierarchy and positions", () => {
+	const { tm } = setup();
+	const a = id(tm.addTask("A"));
+	const b = id(tm.addTask("B", a));
+	const c = id(tm.addTask("C", a, b));
+	const d = id(tm.addTask("D", a));
+	const e = id(tm.addTask("E"));
+	const list = tm.listTasks() as any;
+	assert.deepEqual(
+		list.tasks.map((t: any) => t.id),
+		[a, c, b, d, e],
+	);
+	const byId = Object.fromEntries(list.tasks.map((t: any) => [t.id, t]));
+	assert.equal(byId[b].parent_id, a);
+	assert.equal(byId[b].depth, 1);
+	assert.equal(byId[c].position, 0);
+	assert.equal(byId[b].position, 1);
+});
+
+test("add: invalid parent", () => {
+	const { tm } = setup();
+	const r = tm.addTask("X", "nope12");
+	assert.equal(r.status, "error");
+});
+
+test("edit: no fields is an error", () => {
+	const { tm } = setup();
+	const a = id(tm.addTask("A"));
+	const r = tm.editTask(a);
+	assert.equal(r.status, "error");
+	assert.equal(r.error, "No fields to edit.");
+});
+
+test("edit: invalid status and priority", () => {
+	const { tm } = setup();
+	const a = id(tm.addTask("A"));
+	assert.equal((tm.editTask(a, undefined, "z") as any).status, "error");
+	assert.equal((tm.editTask(a, undefined, undefined, "urgent") as any).status, "error");
+	const ok = tm.editTask(a, "A2", "x", "null") as any;
+	assert.equal(ok.status, "ok");
+	assert.equal(ok.task.description, "A2");
+	assert.equal(ok.task.status, "x");
+	assert.equal(ok.task.priority, null);
+	assert.ok(ok.task.date_done);
+});
+
+test("edit: circular dependency rejected", () => {
+	const { tm } = setup();
+	const a = id(tm.addTask("A"));
+	const b = id(tm.addTask("B"));
+	tm.editTask(b, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, [a]);
+	const r = tm.editTask(a, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, [b]);
+	assert.equal(r.status, "error");
+	assert.match(r.error as string, /Circular/);
+});
+
+test("move: under own descendant rejected", () => {
+	const { tm } = setup();
+	const a = id(tm.addTask("A"));
+	const b = id(tm.addTask("B", a));
+	const r = tm.moveTask(a, b);
+	assert.equal(r.status, "error");
+});
+
+test("move: before later sibling keeps order", () => {
+	const { tm } = setup();
+	const a = id(tm.addTask("A"));
+	const b = id(tm.addTask("B", a));
+	const c = id(tm.addTask("C", a));
+	// b already sits before c; re-inserting "before c" must not swap them
+	// (the index must be computed after detaching b).
+	const r = tm.moveTask(b, a, c);
+	assert.equal(r.status, "ok");
+	const ids = (tm.listTasks().tasks as any[]).map((t) => t.id);
+	assert.deepEqual(ids, [a, b, c]);
+});
+
+test("move: with subtree, positions recomputed", () => {
+	const { tm } = setup();
+	const a = id(tm.addTask("A"));
+	const b = id(tm.addTask("B"));
+	const c = id(tm.addTask("C", b));
+	const d = id(tm.addTask("D"));
+	tm.moveTask(b, a);
+	const list = tm.listTasks() as any;
+	assert.deepEqual(
+		list.tasks.map((t: any) => t.id),
+		[a, b, c, d],
+	);
+	const byId = Object.fromEntries(list.tasks.map((t: any) => [t.id, t]));
+	assert.equal(byId[b].parent_id, a);
+	assert.equal(byId[c].parent_id, b);
+	assert.equal(byId[c].depth, 2);
+});
+
+test("move: no destination deletes task and subtree", () => {
+	const { tm } = setup();
+	const a = id(tm.addTask("A"));
+	const b = id(tm.addTask("B", a));
+	const c = id(tm.addTask("C", b));
+	const r = tm.moveTask(a);
+	assert.equal(r.status, "ok");
+	assert.match(r.message as string, /2 sub-task/);
+	const list = tm.listTasks() as any;
+	assert.equal(list.count, 0);
+});
+
+test("list: filters", () => {
+	const { tm } = setup();
+	const a = id(tm.addTask("A", undefined, undefined, undefined, "high"));
+	tm.addTask("B");
+	tm.editTask(a, undefined, "x");
+	const byStatus = tm.listTasks(undefined, "x") as any;
+	assert.equal(byStatus.count, 1);
+	assert.equal(byStatus.tasks[0].id, a);
+	const byPriority = tm.listTasks(undefined, undefined, "high") as any;
+	assert.equal(byPriority.count, 1);
+	const subtree = tm.listTasks(a, undefined, undefined, true) as any;
+	assert.equal(subtree.count, 1);
+	assert.equal(subtree.tasks[0].id, a);
+});
+
+test("save and close", () => {
+	const { tm, dir } = setup();
+	tm.addTask("A");
+	const s = tm.save() as any;
+	assert.equal(s.status, "ok");
+	assert.equal(s.task_count, 1);
+	const c = tm.closeFile() as any;
+	assert.equal(c.status, "ok");
+	assert.equal(tm.isOpen, false);
+	const r = tm.save();
+	assert.equal(r.status, "error");
+	assert.ok(fs.existsSync(path.join(dir, "TODO.md.bak")));
+});

package/tests/validation.test.ts

@@ -0,0 +1,194 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { TaskManager } from "../lib/task-manager.ts";
+
+function setup() {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "tm-val-"));
+	const tm = new TaskManager();
+	tm.openFile(dir);
+	return { tm, dir };
+}
+
+const id = (r: Record<string, unknown>) => r.task_id as string;
+
+// ── addTask validation ────────────────────────────────────────────────
+
+test("addTask: rejects multiline description", () => {
+	const { tm } = setup();
+	const r = tm.addTask("line1\nline2");
+	assert.equal(r.status, "error");
+	assert.match(r.error as string, /newline/i);
+});
+
+test("addTask: rejects invalid scheduled date", () => {
+	const { tm } = setup();
+	const r = tm.addTask("A", undefined, undefined, undefined, undefined, "tomorrow");
+	assert.equal(r.status, "error");
+	assert.match(r.error as string, /scheduled/i);
+});
+
+test("addTask: rejects invalid start date", () => {
+	const { tm } = setup();
+	const r = tm.addTask("A", undefined, undefined, undefined, undefined, undefined, "2026-1-1");
+	assert.equal(r.status, "error");
+	assert.match(r.error as string, /start/i);
+});
+
+test("addTask: rejects invalid due date", () => {
+	const { tm } = setup();
+	const r = tm.addTask("A", undefined, undefined, undefined, undefined, undefined, undefined, "15/08/2026");
+	assert.equal(r.status, "error");
+	assert.match(r.error as string, /due/i);
+});
+
+test("addTask: rejects invalid priority", () => {
+	const { tm } = setup();
+	const r = tm.addTask("A", undefined, undefined, undefined, "urgent");
+	assert.equal(r.status, "error");
+	assert.match(r.error as string, /priority/i);
+});
+
+test("addTask: accepts valid dates and priority", () => {
+	const { tm } = setup();
+	const r = tm.addTask(
+		"A",
+		undefined,
+		undefined,
+		undefined,
+		"high",
+		"2026-09-01",
+		"2026-09-02",
+		"2026-09-03",
+	);
+	assert.equal(r.status, "ok");
+	const t = tm.getTask(id(r)) as any;
+	assert.equal(t.task.priority, "high");
+	assert.equal(t.task.date_scheduled, "2026-09-01");
+	assert.equal(t.task.date_start, "2026-09-02");
+	assert.equal(t.task.date_due, "2026-09-03");
+});
+
+// ── editTask validation ───────────────────────────────────────────────
+
+test("editTask: rejects multiline description", () => {
+	const { tm } = setup();
+	const a = id(tm.addTask("A"));
+	const r = tm.editTask(a, "line1\nline2");
+	assert.equal(r.status, "error");
+	assert.match(r.error as string, /newline/i);
+});
+
+test("editTask: rejects invalid dates", () => {
+	const { tm } = setup();
+	const a = id(tm.addTask("A"));
+	assert.equal((tm.editTask(a, undefined, undefined, undefined, "tomorrow") as any).status, "error");
+	assert.equal((tm.editTask(a, undefined, undefined, undefined, undefined, "tomorrow") as any).status, "error");
+	assert.equal((tm.editTask(a, undefined, undefined, undefined, undefined, undefined, "tomorrow") as any).status, "error");
+});
+
+// ── openFile validation: orphaned indented lines ─────────────────────
+
+test("openFile: rejects orphaned indented lines (missing ancestor)", () => {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "tm-val-"));
+	const orphan = `# TODO
+
+- [ ] Parent (ID: \`a1b2c3\`)
+    - [ ] Orphan at depth 2 (ID: \`x1y2z3\`)
+`;
+	fs.writeFileSync(path.join(dir, "TODO.md"), orphan);
+	const tm = new TaskManager();
+	const r = tm.openFile(dir);
+	assert.equal(r.status, "error");
+	assert.match(r.error as string, /orphan/i);
+	assert.equal(tm.isOpen, false);
+});
+
+test("openFile: rejects indented line with no root at all", () => {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "tm-val-"));
+	const orphan = `# TODO
+
+  - [ ] Indented but no ancestor (ID: \`q1w2e3\`)
+`;
+	fs.writeFileSync(path.join(dir, "TODO.md"), orphan);
+	const tm = new TaskManager();
+	const r = tm.openFile(dir);
+	assert.equal(r.status, "error");
+	assert.match(r.error as string, /orphan/i);
+	assert.equal(tm.isOpen, false);
+});
+
+test("openFile: rejects tab indentation", () => {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "tm-val-"));
+	const tabbed = `# TODO
+
+- [ ] Root (ID: \`a1b2c3\`)
+\t- [ ] Tab child (ID: \`x1y2z3\`)
+`;
+	fs.writeFileSync(path.join(dir, "TODO.md"), tabbed);
+	const tm = new TaskManager();
+	const r = tm.openFile(dir);
+	assert.equal(r.status, "error");
+	assert.match(r.error as string, /tab/i);
+	assert.equal(tm.isOpen, false);
+});
+
+test("openFile: rejects duplicate task IDs", () => {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "tm-val-"));
+	const dups = `# TODO
+
+- [ ] A (ID: \`a1b2c3\`)
+- [ ] B (ID: \`a1b2c3\`)
+`;
+	fs.writeFileSync(path.join(dir, "TODO.md"), dups);
+	const tm = new TaskManager();
+	const r = tm.openFile(dir);
+	assert.equal(r.status, "error");
+	assert.match(r.error as string, /duplicate/i);
+	assert.equal(tm.isOpen, false);
+});
+
+test("openFile: accepts properly nested file", () => {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "tm-val-"));
+	const valid = `# TODO
+
+- [ ] A (ID: \`a1b2c3\`)
+  - [ ] B (ID: \`d4e5f6\`)
+    - [ ] C (ID: \`g7h8i9\`)
+- [ ] D (ID: \`j1k2l3\`)
+`;
+	fs.writeFileSync(path.join(dir, "TODO.md"), valid);
+	const tm = new TaskManager();
+	const r = tm.openFile(dir);
+	assert.equal(r.status, "ok");
+	assert.equal((r as any).task_count, 4);
+	tm.closeFile();
+});
+
+// ── round-trip guard: valid data survives save/reopen ─────────────────
+
+test("round-trip: valid dates + priority survive save/reopen", () => {
+	const { tm, dir } = setup();
+	const a = id(
+		tm.addTask(
+			"A",
+			undefined,
+			undefined,
+			undefined,
+			"high",
+			"2026-09-01",
+			"2026-09-02",
+			"2026-09-03",
+		),
+	);
+	tm.closeFile();
+	const tm2 = new TaskManager();
+	tm2.openFile(dir);
+	const t = tm2.getTask(a) as any;
+	assert.equal(t.task.priority, "high");
+	assert.equal(t.task.date_scheduled, "2026-09-01");
+	assert.equal(t.task.date_start, "2026-09-02");
+	assert.equal(t.task.date_due, "2026-09-03");
+});

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		"strict": true,
+		"noEmit": true,
+		"skipLibCheck": true,
+		"allowImportingTsExtensions": true,
+		"verbatimModuleSyntax": true,
+		"paths": {
+			"@earendil-works/pi-ai": [
+				"/home/gil/.local/share/pi-node/node-v22.23.2-linux-x64/lib/node_modules/@earendil-works/pi-coding-agent/node_modules/@earendil-works/pi-ai/dist/index.d.ts"
+			],
+			"@earendil-works/pi-coding-agent": [
+				"/home/gil/.local/share/pi-node/node-v22.23.2-linux-x64/lib/node_modules/@earendil-works/pi-coding-agent/dist/index.d.ts"
+			]
+		}
+	},
+	"include": ["index.ts", "lib", "tests"]
+}