@dailephd/my-dev-kit-lab 0.2.0

package/benchmarks/projects/task-workflow-medium-ts/tests/createTask.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest";
+import { createTask } from "../src/services/createTask.js";
+import { TaskWorkflowStore } from "../src/store/taskStore.js";
+
+describe("createTask", () => {
+  it("creates deterministic task ids inside known projects", () => {
+    const store = new TaskWorkflowStore({
+      projects: [{ id: "alpha", name: "Alpha", slug: "alpha", archived: false }]
+    });
+    expect(createTask(store, { title: "Ship report", projectId: "alpha" }).id).toBe("task-1");
+    expect(createTask(store, { title: "Review notes", projectId: "alpha" }).id).toBe("task-2");
+  });
+
+  it("rejects blank titles and unknown projects", () => {
+    const store = new TaskWorkflowStore({
+      projects: [{ id: "alpha", name: "Alpha", slug: "alpha", archived: false }]
+    });
+    expect(() => createTask(store, { title: "   ", projectId: "alpha" })).toThrow("Task title must not be empty.");
+    expect(() => createTask(store, { title: "Ready", projectId: "missing" })).toThrow("Unknown project id: missing");
+  });
+});

package/benchmarks/projects/task-workflow-medium-ts/tests/filterTasks.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { completeTask } from "../src/services/completeTask.js";
+import { createTask } from "../src/services/createTask.js";
+import { filterTasks } from "../src/services/filterTasks.js";
+import { TaskWorkflowStore } from "../src/store/taskStore.js";
+
+describe("filterTasks", () => {
+  it("filters by query, tag, priority, and completion state", () => {
+    const store = new TaskWorkflowStore({
+      projects: [{ id: "alpha", name: "Alpha", slug: "alpha", archived: false }]
+    });
+    const first = createTask(store, { title: "Ship release notes", projectId: "alpha", priority: "high", tags: ["Docs"] });
+    createTask(store, { title: "Review pipeline", projectId: "alpha", priority: "medium", tags: ["ops"] });
+    completeTask(store, first.id);
+    expect(filterTasks(store, { query: "pipeline" }).map((task) => task.title)).toEqual(["Review pipeline"]);
+    expect(filterTasks(store, { tag: "docs", completed: true }).map((task) => task.id)).toEqual([first.id]);
+  });
+});

package/benchmarks/projects/task-workflow-medium-ts/tests/importTasks.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { importTasks } from "../src/services/importTasks.js";
+import { TaskWorkflowStore } from "../src/store/taskStore.js";
+
+describe("importTasks", () => {
+  it("imports tasks with deterministic ids and skips duplicate normalized titles inside the same project", () => {
+    const store = new TaskWorkflowStore({
+      projects: [{ id: "alpha", name: "Alpha", slug: "alpha", archived: false }]
+    });
+    const result = importTasks(
+      store,
+      [
+        { title: "Ship report", projectId: "alpha", tags: ["Docs"] },
+        { title: "  Ship   report ", projectId: "alpha", tags: ["docs"] },
+        { title: "Audit metrics", projectId: "alpha", priority: "high" }
+      ],
+      "csv"
+    );
+    expect(result.imported.map((task) => task.id)).toEqual(["task-1", "task-2"]);
+    expect(result.skippedDuplicates).toEqual(["task-1"]);
+  });
+});

package/benchmarks/projects/task-workflow-medium-ts/tests/summarizeTasks.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+import { completeTask } from "../src/services/completeTask.js";
+import { createTask } from "../src/services/createTask.js";
+import { summarizeTasks } from "../src/services/summarizeTasks.js";
+import { TaskWorkflowStore } from "../src/store/taskStore.js";
+
+describe("summarizeTasks", () => {
+  it("reports totals, per-project counts, and high-priority open titles", () => {
+    const store = new TaskWorkflowStore({
+      projects: [
+        { id: "alpha", name: "Alpha", slug: "alpha", archived: false },
+        { id: "beta", name: "Beta", slug: "beta", archived: false }
+      ]
+    });
+    const first = createTask(store, { title: "Ship report", projectId: "alpha", priority: "high" });
+    createTask(store, { title: "Audit logs", projectId: "beta", priority: "medium" });
+    completeTask(store, first.id);
+    expect(summarizeTasks(store)).toEqual({
+      total: 2,
+      completed: 1,
+      open: 1,
+      byProject: {
+        alpha: { total: 1, completed: 1, open: 0 },
+        beta: { total: 1, completed: 0, open: 1 }
+      },
+      highPriorityOpenTitles: []
+    });
+  });
+});

package/benchmarks/projects/task-workflow-medium-ts/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "types": ["vitest/globals"]
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts"]
+}

package/benchmarks/projects/task-workflow-medium-ts/vitest.config.ts

@@ -0,0 +1,5 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  cacheDir: "../../../.vitest/task-workflow-medium-ts"
+});

package/benchmarks/projects/todo-js/README.md

@@ -0,0 +1,3 @@
+# todo-js
+
+Deterministic JavaScript Todo Core benchmark project.

package/benchmarks/projects/todo-js/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "todo-js-benchmark",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "vitest": "^3.2.4"
+  }
+}

package/benchmarks/projects/todo-js/src/index.js

@@ -0,0 +1,2 @@
+export { TaskStore } from "./taskStore.js";
+export { TaskService } from "./taskService.js";

package/benchmarks/projects/todo-js/src/taskService.js

@@ -0,0 +1,37 @@
+import { TaskStore } from "./taskStore.js";
+
+export class TaskService {
+  constructor(store = new TaskStore()) {
+    this.store = store;
+  }
+
+  createTask(title) {
+    const normalized = title.trim();
+    if (!normalized) {
+      throw new Error("Task title must not be empty.");
+    }
+    return this.store.create(normalized);
+  }
+
+  completeTask(id) {
+    return this.store.update(id, (task) => ({ ...task, completed: true }));
+  }
+
+  listTasks() {
+    return this.store.list();
+  }
+
+  listOpenTasks() {
+    return this.store.list().filter((task) => !task.completed);
+  }
+
+  summarizeTasks() {
+    const tasks = this.store.list();
+    const completed = tasks.filter((task) => task.completed).length;
+    return {
+      total: tasks.length,
+      open: tasks.length - completed,
+      completed
+    };
+  }
+}

package/benchmarks/projects/todo-js/src/taskStore.js

@@ -0,0 +1,28 @@
+export class TaskStore {
+  #tasks = [];
+  #nextId = 1;
+
+  create(title) {
+    const task = {
+      id: `task-${this.#nextId++}`,
+      title,
+      completed: false
+    };
+    this.#tasks.push(task);
+    return { ...task };
+  }
+
+  update(taskId, updater) {
+    const index = this.#tasks.findIndex((task) => task.id === taskId);
+    if (index === -1) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+    const updated = updater(this.#tasks[index]);
+    this.#tasks[index] = updated;
+    return { ...updated };
+  }
+
+  list() {
+    return this.#tasks.map((task) => ({ ...task }));
+  }
+}

package/benchmarks/projects/todo-js/tests/taskService.test.js

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import { TaskService } from "../src/taskService.js";
+
+describe("todo-js TaskService", () => {
+  it("creates tasks with deterministic ids", () => {
+    const service = new TaskService();
+    expect(service.createTask("First").id).toBe("task-1");
+    expect(service.createTask("Second").id).toBe("task-2");
+  });
+
+  it("completes tasks", () => {
+    const service = new TaskService();
+    const created = service.createTask("Ship benchmark");
+    const completed = service.completeTask(created.id);
+    expect(completed.completed).toBe(true);
+  });
+
+  it("lists all tasks", () => {
+    const service = new TaskService();
+    service.createTask("One");
+    service.createTask("Two");
+    expect(service.listTasks()).toHaveLength(2);
+  });
+
+  it("lists open tasks", () => {
+    const service = new TaskService();
+    const one = service.createTask("One");
+    service.createTask("Two");
+    service.completeTask(one.id);
+    expect(service.listOpenTasks().map((task) => task.title)).toEqual(["Two"]);
+  });
+
+  it("summarizes task counts", () => {
+    const service = new TaskService();
+    const one = service.createTask("One");
+    service.createTask("Two");
+    service.completeTask(one.id);
+    expect(service.summarizeTasks()).toEqual({ total: 2, open: 1, completed: 1 });
+  });
+
+  it("rejects empty task titles", () => {
+    const service = new TaskService();
+    expect(() => service.createTask("   ")).toThrowError("Task title must not be empty.");
+  });
+});

package/benchmarks/projects/todo-js/vitest.config.js

@@ -0,0 +1,5 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  cacheDir: "../../../.vitest/todo-js"
+});

package/benchmarks/projects/todo-mixed-ts-py/README.md

@@ -0,0 +1,3 @@
+# todo-mixed-ts-py
+
+Deterministic mixed TypeScript and Python Todo Core benchmark project.

package/benchmarks/projects/todo-mixed-ts-py/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "todo-mixed-ts-py-benchmark",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
+  }
+}

package/benchmarks/projects/todo-mixed-ts-py/python/task_service.py

@@ -0,0 +1,76 @@
+import json
+import sys
+
+
+class TaskService:
+    def __init__(self) -> None:
+        self._tasks = []
+        self._next_id = 1
+
+    def create_task(self, title: str) -> dict:
+        normalized = title.strip()
+        if not normalized:
+            raise ValueError("Task title must not be empty.")
+        task = {
+            "id": f"task-{self._next_id}",
+            "title": normalized,
+            "completed": False,
+        }
+        self._next_id += 1
+        self._tasks.append(task)
+        return dict(task)
+
+    def complete_task(self, task_id: str) -> dict:
+        for task in self._tasks:
+            if task["id"] == task_id:
+                task["completed"] = True
+                return dict(task)
+        raise ValueError(f"Task not found: {task_id}")
+
+    def list_tasks(self) -> list:
+        return [dict(task) for task in self._tasks]
+
+    def list_open_tasks(self) -> list:
+        return [dict(task) for task in self._tasks if not task["completed"]]
+
+    def summarize_tasks(self) -> dict:
+        completed = len([task for task in self._tasks if task["completed"]])
+        return {
+            "total": len(self._tasks),
+            "open": len(self._tasks) - completed,
+            "completed": completed,
+        }
+
+
+def run_operations(payload: dict) -> dict:
+    service = TaskService()
+    results = []
+    for operation in payload["operations"]:
+        op_type = operation["type"]
+        if op_type == "createTask":
+            results.append(service.create_task(operation["title"]))
+        elif op_type == "completeTask":
+            results.append(service.complete_task(operation["id"]))
+        elif op_type == "listTasks":
+            results.append(service.list_tasks())
+        elif op_type == "listOpenTasks":
+            results.append(service.list_open_tasks())
+        elif op_type == "summarizeTasks":
+            results.append(service.summarize_tasks())
+        else:
+            raise ValueError(f"Unsupported operation: {op_type}")
+    return {"results": results}
+
+
+def main() -> int:
+    try:
+        payload = json.loads(sys.stdin.read())
+        sys.stdout.write(json.dumps(run_operations(payload)))
+        return 0
+    except Exception as error:
+        sys.stderr.write(str(error))
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/benchmarks/projects/todo-mixed-ts-py/src/taskCli.ts

@@ -0,0 +1,38 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolvePythonCommand } from "../../../../src/core/pythonCommand.js";
+
+export type Operation =
+  | { type: "createTask"; title: string }
+  | { type: "completeTask"; id: string }
+  | { type: "listTasks" }
+  | { type: "listOpenTasks" }
+  | { type: "summarizeTasks" };
+
+export function runTodoScenario(operations: Operation[]) {
+  const currentDir = path.dirname(fileURLToPath(import.meta.url));
+  const scriptPath = path.resolve(currentDir, "../python/task_service.py");
+  const python = resolvePythonCommand();
+  const result = spawnSync(python.command, [...python.argsPrefix, scriptPath], {
+    input: JSON.stringify({ operations }),
+    encoding: "utf8",
+    shell: false,
+    timeout: 10_000,
+    windowsHide: true
+  });
+
+  if (result.status !== 0) {
+    const details = [
+      `command=${python.command}`,
+      `args=${JSON.stringify([...python.argsPrefix, scriptPath])}`,
+      `status=${String(result.status)}`,
+      `signal=${String(result.signal)}`,
+      `error=${result.error?.message ?? ""}`,
+      `stderr=${result.stderr.trim()}`
+    ].join("\n");
+    throw new Error(details || "Mixed benchmark Python process failed.");
+  }
+
+  return JSON.parse(result.stdout) as { results: unknown[] };
+}

package/benchmarks/projects/todo-mixed-ts-py/tests/mixedBoundary.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { runTodoScenario } from "../src/taskCli.js";
+
+describe("todo-mixed-ts-py boundary", () => {
+  it("runs deterministic todo behavior through the TypeScript to Python boundary", () => {
+    const result = runTodoScenario([
+      { type: "createTask", title: "One" },
+      { type: "createTask", title: "Two" },
+      { type: "completeTask", id: "task-1" },
+      { type: "listOpenTasks" },
+      { type: "summarizeTasks" }
+    ]);
+
+    expect(result.results.at(0)).toEqual({ id: "task-1", title: "One", completed: false });
+    expect(result.results.at(3)).toEqual([{ id: "task-2", title: "Two", completed: false }]);
+    expect(result.results.at(4)).toEqual({ total: 2, open: 1, completed: 1 });
+  });
+});

package/benchmarks/projects/todo-mixed-ts-py/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "types": ["node", "vitest/globals"]
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts"]
+}

package/benchmarks/projects/todo-mixed-ts-py/vitest.config.ts

@@ -0,0 +1,5 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  cacheDir: "../../../.vitest/todo-mixed-ts-py"
+});

package/benchmarks/projects/todo-python/README.md

@@ -0,0 +1,3 @@
+# todo-python
+
+Deterministic Python Todo Core benchmark project.

package/benchmarks/projects/todo-python/src/__init__.py

@@ -0,0 +1,4 @@
+from .task_service import TaskService
+from .task_store import TaskStore
+
+__all__ = ["TaskService", "TaskStore"]

package/benchmarks/projects/todo-python/src/task_service.py

@@ -0,0 +1,32 @@
+from typing import Optional
+
+from task_store import TaskStore
+
+
+class TaskService:
+    def __init__(self, store: Optional[TaskStore] = None) -> None:
+        self._store = store or TaskStore()
+
+    def create_task(self, title: str) -> dict:
+        normalized = title.strip()
+        if not normalized:
+            raise ValueError("Task title must not be empty.")
+        return self._store.create(normalized)
+
+    def complete_task(self, task_id: str) -> dict:
+        return self._store.update(task_id, lambda task: {**task, "completed": True})
+
+    def list_tasks(self) -> list:
+        return self._store.list()
+
+    def list_open_tasks(self) -> list:
+        return [task for task in self._store.list() if not task["completed"]]
+
+    def summarize_tasks(self) -> dict:
+        tasks = self._store.list()
+        completed = len([task for task in tasks if task["completed"]])
+        return {
+            "total": len(tasks),
+            "open": len(tasks) - completed,
+            "completed": completed,
+        }

package/benchmarks/projects/todo-python/src/task_store.py

@@ -0,0 +1,28 @@
+from copy import deepcopy
+
+
+class TaskStore:
+    def __init__(self) -> None:
+        self._tasks = []
+        self._next_id = 1
+
+    def create(self, title: str) -> dict:
+        task = {
+            "id": f"task-{self._next_id}",
+            "title": title,
+            "completed": False,
+        }
+        self._next_id += 1
+        self._tasks.append(task)
+        return deepcopy(task)
+
+    def update(self, task_id: str, updater) -> dict:
+        for index, task in enumerate(self._tasks):
+            if task["id"] == task_id:
+                updated = updater(deepcopy(task))
+                self._tasks[index] = deepcopy(updated)
+                return deepcopy(updated)
+        raise ValueError(f"Task not found: {task_id}")
+
+    def list(self) -> list:
+        return deepcopy(self._tasks)

package/benchmarks/projects/todo-python/tests/test_task_service.py

@@ -0,0 +1,52 @@
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
+
+from task_service import TaskService
+
+
+class TaskServiceTests(unittest.TestCase):
+    def test_creates_tasks_with_deterministic_ids(self) -> None:
+        service = TaskService()
+        self.assertEqual(service.create_task("First")["id"], "task-1")
+        self.assertEqual(service.create_task("Second")["id"], "task-2")
+
+    def test_completes_tasks(self) -> None:
+        service = TaskService()
+        created = service.create_task("Ship benchmark")
+        completed = service.complete_task(created["id"])
+        self.assertTrue(completed["completed"])
+
+    def test_lists_all_tasks(self) -> None:
+        service = TaskService()
+        service.create_task("One")
+        service.create_task("Two")
+        self.assertEqual(len(service.list_tasks()), 2)
+
+    def test_lists_open_tasks(self) -> None:
+        service = TaskService()
+        first = service.create_task("One")
+        service.create_task("Two")
+        service.complete_task(first["id"])
+        self.assertEqual([task["title"] for task in service.list_open_tasks()], ["Two"])
+
+    def test_summarizes_tasks(self) -> None:
+        service = TaskService()
+        first = service.create_task("One")
+        service.create_task("Two")
+        service.complete_task(first["id"])
+        self.assertEqual(
+            service.summarize_tasks(),
+            {"total": 2, "open": 1, "completed": 1},
+        )
+
+    def test_rejects_empty_task_titles(self) -> None:
+        service = TaskService()
+        with self.assertRaisesRegex(ValueError, "Task title must not be empty."):
+            service.create_task("   ")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/benchmarks/projects/todo-ts/README.md

@@ -0,0 +1,3 @@
+# todo-ts
+
+Deterministic TypeScript Todo Core benchmark project.

package/benchmarks/projects/todo-ts/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "todo-ts-benchmark",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
+  }
+}

package/benchmarks/projects/todo-ts/src/index.ts

@@ -0,0 +1,2 @@
+export { TaskStore } from "./taskStore.js";
+export { TaskService } from "./taskService.js";

package/benchmarks/projects/todo-ts/src/taskService.ts

@@ -0,0 +1,41 @@
+import { TaskStore, type Task } from "./taskStore.js";
+
+export type TaskSummary = {
+  total: number;
+  open: number;
+  completed: number;
+};
+
+export class TaskService {
+  constructor(private readonly store = new TaskStore()) {}
+
+  createTask(title: string): Task {
+    const normalized = title.trim();
+    if (!normalized) {
+      throw new Error("Task title must not be empty.");
+    }
+    return this.store.create(normalized);
+  }
+
+  completeTask(id: string): Task {
+    return this.store.update(id, (task) => ({ ...task, completed: true }));
+  }
+
+  listTasks(): Task[] {
+    return this.store.list();
+  }
+
+  listOpenTasks(): Task[] {
+    return this.store.list().filter((task) => !task.completed);
+  }
+
+  summarizeTasks(): TaskSummary {
+    const tasks = this.store.list();
+    const completed = tasks.filter((task) => task.completed).length;
+    return {
+      total: tasks.length,
+      open: tasks.length - completed,
+      completed
+    };
+  }
+}

package/benchmarks/projects/todo-ts/src/taskStore.ts

@@ -0,0 +1,34 @@
+export type Task = {
+  id: string;
+  title: string;
+  completed: boolean;
+};
+
+export class TaskStore {
+  private tasks: Task[] = [];
+  private nextId = 1;
+
+  create(title: string): Task {
+    const task: Task = {
+      id: `task-${this.nextId++}`,
+      title,
+      completed: false
+    };
+    this.tasks.push(task);
+    return { ...task };
+  }
+
+  update(taskId: string, updater: (task: Task) => Task): Task {
+    const index = this.tasks.findIndex((task) => task.id === taskId);
+    if (index === -1) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+    const updated = updater(this.tasks[index]);
+    this.tasks[index] = updated;
+    return { ...updated };
+  }
+
+  list(): Task[] {
+    return this.tasks.map((task) => ({ ...task }));
+  }
+}