@linzumi/cli 1.0.31 → 1.0.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "description": "Linzumi CLI \u2014 point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {

package/scripts/f2-task-graph-mcp-e2e.mjs

@@ -0,0 +1,281 @@
+/*
+- Date: 2026-07-04
+  Spec: plans/2026-07-04-projects-followups-stack.md (F2)
+  Relationship: Scripted MCP-client execution proof for the project task-graph
+  tools. Spawns the REAL shipped MCP server (`linzumi mcp` over stdio, text
+  mode, tool scope all) against a locally running kandan server and exercises
+  every tool end to end: list projects, read the graph, create a group +
+  issues (assignment included), wire dependency edges, verify derived
+  launch-readiness flips as prerequisites complete, refuse a cycle (with the
+  human-legible path), reorganize (move into/out of a group, reorder), hit the
+  optimistic-lock staleness guard, remove an edge, delete a task, and read the
+  final graph. Prints a full transcript and exits non-zero on any failed
+  expectation.
+
+  Usage (see kandan/server_v2/scripts/f2_task_graph_mcp_seed.exs for seeding):
+    node scripts/f2-task-graph-mcp-e2e.mjs \
+      --api-url http://127.0.0.1:4199 \
+      --seed-json '<output of the seed script>'
+*/
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+const args = process.argv.slice(2);
+const argValue = (flag) => {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
+};
+
+const apiUrl = argValue('--api-url') ?? 'http://127.0.0.1:4199';
+const seed = JSON.parse(argValue('--seed-json') ?? '{}');
+if (!seed.token || !seed.project_id) {
+  console.error(
+    'missing --seed-json (run kandan/server_v2/scripts/f2_task_graph_mcp_seed.exs)'
+  );
+  process.exit(2);
+}
+
+const packageRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '..'
+);
+
+let failures = 0;
+const check = (label, condition) => {
+  const mark = condition ? 'PASS' : 'FAIL';
+  if (!condition) failures += 1;
+  console.log(`  [${mark}] ${label}`);
+};
+
+let step = 0;
+const client = new Client({ name: 'f2-e2e-proof', version: '0.0.0' });
+
+const callTool = async (name, params) => {
+  step += 1;
+  console.log(`\n=== step ${step}: ${name} ${JSON.stringify(params)}`);
+  try {
+    const result = await client.callTool({ name, arguments: params });
+    const text = result.content?.[0]?.text ?? '{}';
+    if (result.isError) {
+      // Tool-level refusals surface as isError text content (the thrown
+      // client error message), not JSON.
+      console.log(`TOOL ERROR: ${text}`);
+      return { __tool_error__: text };
+    }
+    const parsed = JSON.parse(text);
+    console.log(JSON.stringify(parsed, null, 2));
+    return parsed;
+  } catch (error) {
+    const message = String(error?.message ?? error);
+    console.log(`TOOL ERROR: ${message}`);
+    return { __tool_error__: message };
+  }
+};
+
+const transport = new StdioClientTransport({
+  command: process.execPath,
+  args: [
+    path.join(packageRoot, 'bin', 'linzumi.js'),
+    'mcp',
+    'server',
+    '--api-url',
+    apiUrl,
+    '--mode',
+    'text',
+    '--tool-scope',
+    'all',
+  ],
+  env: {
+    ...process.env,
+    LINZUMI_MCP_ACCESS_TOKEN: seed.token,
+  },
+});
+
+await client.connect(transport);
+
+console.log('=== tools/list');
+const tools = await client.listTools();
+const toolNames = tools.tools.map((tool) => tool.name);
+const expectedTools = [
+  'linzumi_list_projects',
+  'linzumi_get_project_tasks',
+  'linzumi_create_project_task',
+  'linzumi_update_project_task',
+  'linzumi_delete_project_task',
+  'linzumi_add_project_task_dependency',
+  'linzumi_remove_project_task_dependency',
+];
+for (const tool of expectedTools) {
+  check(`tools/list advertises ${tool}`, toolNames.includes(tool));
+}
+
+// 1. Discover the project.
+const projects = await callTool('linzumi_list_projects', {});
+check(
+  'list_projects returns the seeded project',
+  projects.projects?.some((entry) => entry.project_id === seed.project_id)
+);
+const projectId = seed.project_id;
+
+// 2. Empty graph read.
+const emptyGraph = await callTool('linzumi_get_project_tasks', {
+  project_id: projectId,
+});
+check('graph starts empty', emptyGraph.tasks?.length === 0);
+
+// 3. Create a group and three issues (one assigned, one grouped).
+const group = await callTool('linzumi_create_project_task', {
+  project_id: projectId,
+  title: 'Milestone 1',
+  kind: 'group',
+});
+check('group created', group.task?.kind === 'group');
+
+const design = await callTool('linzumi_create_project_task', {
+  project_id: projectId,
+  title: 'Design the schema',
+  description: 'Commented DDL + SDL diff first.',
+  parent_id: group.task?.task_id,
+  assignee: seed.teammate,
+});
+check(
+  'issue created inside the group',
+  design.task?.parent_task_id === group.task?.task_id
+);
+check('issue assigned by username', design.task?.assignee === seed.teammate);
+
+const implement = await callTool('linzumi_create_project_task', {
+  project_id: projectId,
+  title: 'Implement the API',
+});
+const docs = await callTool('linzumi_create_project_task', {
+  project_id: projectId,
+  title: 'Write the docs',
+});
+
+// 4. Wire the DAG: implement <- design, docs <- implement.
+const edge1 = await callTool('linzumi_add_project_task_dependency', {
+  task_id: implement.task?.task_id,
+  depends_on_task_id: design.task?.task_id,
+});
+check(
+  'dependency added blocks the dependent',
+  edge1.task?.work_state === 'blocked'
+);
+
+await callTool('linzumi_add_project_task_dependency', {
+  task_id: docs.task?.task_id,
+  depends_on_task_id: implement.task?.task_id,
+});
+
+const wiredGraph = await callTool('linzumi_get_project_tasks', {
+  project_id: projectId,
+});
+const wiredStates = Object.fromEntries(
+  (wiredGraph.tasks ?? []).map((task) => [task.title, task.work_state])
+);
+check(
+  'readiness derives from the edges (design ready)',
+  wiredStates['Design the schema'] === 'ready'
+);
+check(
+  'implement blocked behind design',
+  wiredStates['Implement the API'] === 'blocked'
+);
+check(
+  'docs blocked behind implement',
+  wiredStates['Write the docs'] === 'blocked'
+);
+
+// 5. Acyclicity: design <- docs would close the loop; expect the refusal + path.
+const cycle = await callTool('linzumi_add_project_task_dependency', {
+  task_id: design.task?.task_id,
+  depends_on_task_id: docs.task?.task_id,
+});
+check(
+  'cycle refused',
+  cycle.status === 'refused' && cycle.reason === 'would_create_cycle'
+);
+check(
+  'cycle path is human-legible',
+  Array.isArray(cycle.cycle_path) && cycle.cycle_path.length >= 2
+);
+
+// 6. Status transition: finishing design makes implement ready.
+const done = await callTool('linzumi_update_project_task', {
+  task_id: design.task?.task_id,
+  status: 'done',
+  status_note: 'Schema landed.',
+  lock_version: design.task?.lock_version,
+});
+check('status transition applied', done.task?.status === 'done');
+
+const readyGraph = await callTool('linzumi_get_project_tasks', {
+  project_id: projectId,
+});
+const readyStates = Object.fromEntries(
+  (readyGraph.tasks ?? []).map((task) => [task.title, task.work_state])
+);
+check(
+  'launch-readiness reflects the completed prerequisite',
+  readyStates['Implement the API'] === 'ready'
+);
+check('summary counts one done issue', readyGraph.summary?.done === 1);
+
+// 7. Reorganize: move docs into the group, reorder, then back to top level.
+const moved = await callTool('linzumi_update_project_task', {
+  task_id: docs.task?.task_id,
+  parent_id: group.task?.task_id,
+  position: 0,
+});
+check(
+  'issue moved into the group',
+  moved.task?.parent_task_id === group.task?.task_id
+);
+
+const movedOut = await callTool('linzumi_update_project_task', {
+  task_id: docs.task?.task_id,
+  clear_parent: true,
+});
+check('issue moved back to top level', movedOut.task?.parent_task_id === null);
+
+// 8. Optimistic lock: replaying design's original lock_version must fail loudly.
+const stale = await callTool('linzumi_update_project_task', {
+  task_id: design.task?.task_id,
+  title: 'Clobber attempt',
+  lock_version: design.task?.lock_version,
+});
+check(
+  'stale write refused',
+  String(stale.__tool_error__ ?? '').includes('stale')
+);
+
+// 9. Remove an edge: docs no longer waits on implement.
+const removed = await callTool('linzumi_remove_project_task_dependency', {
+  task_id: docs.task?.task_id,
+  depends_on_task_id: implement.task?.task_id,
+});
+check('edge removed frees the dependent', removed.task?.work_state === 'ready');
+
+// 10. Delete: docs leaves the graph.
+const deleted = await callTool('linzumi_delete_project_task', {
+  task_id: docs.task?.task_id,
+});
+check('task deleted', deleted.deleted_task_id === docs.task?.task_id);
+
+const finalGraph = await callTool('linzumi_get_project_tasks', {
+  project_id: projectId,
+});
+check(
+  'final graph has 3 tasks (group + 2 issues)',
+  finalGraph.tasks?.length === 3
+);
+
+await client.close();
+
+console.log(
+  `\n=== ${failures === 0 ? 'ALL CHECKS PASSED' : `${failures} CHECK(S) FAILED`}`
+);
+process.exit(failures === 0 ? 0 : 1);