@cliangdev/flux-plugin 0.2.0-dev.dc5e2c4 → 0.2.0-dev.f718bcf

package/src/server/db/schema.ts

@@ -77,6 +77,15 @@ CREATE TABLE IF NOT EXISTS task_dependencies (
   FOREIGN KEY (depends_on_task_id) REFERENCES tasks(id)
 );
 
+-- PRD Dependencies
+CREATE TABLE IF NOT EXISTS prd_dependencies (
+  prd_id TEXT NOT NULL,
+  depends_on_prd_id TEXT NOT NULL,
+  PRIMARY KEY (prd_id, depends_on_prd_id),
+  FOREIGN KEY (prd_id) REFERENCES prds(id),
+  FOREIGN KEY (depends_on_prd_id) REFERENCES prds(id)
+);
+
 -- Indexes for common queries
 CREATE INDEX IF NOT EXISTS idx_prds_project ON prds(project_id);
 CREATE INDEX IF NOT EXISTS idx_prds_status ON prds(status);

package/src/server/index.ts

@@ -11,7 +11,6 @@ import {
   createTaskTool,
   deleteEntityTool,
   getEntityTool,
-  getProjectContextTool,
   getStatsTool,
   getVersionTool,
   initProjectTool,
@@ -47,7 +46,6 @@ const tools: ToolDefinition[] = [
   // Query tools
   getEntityTool,
   queryEntitiesTool,
-  getProjectContextTool,
   initProjectTool,
   getStatsTool,
   getVersionTool,

package/src/server/tools/__tests__/crud.test.ts

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
 // Set up test environment BEFORE any imports
-const TEST_DIR = `/tmp/flux-test-${Date.now()}`;
+const TEST_DIR = `/tmp/flux-test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
 const FLUX_DIR = join(TEST_DIR, ".flux");
 process.env.FLUX_PROJECT_ROOT = TEST_DIR;
 
@@ -22,6 +22,7 @@ import { updateStatusTool } from "../update-status.js";
 
 describe("CRUD MCP Tools", () => {
   beforeEach(() => {
+    closeDb();
     config.clearCache();
     clearAdapterCache();
     process.env.FLUX_PROJECT_ROOT = TEST_DIR;
@@ -53,6 +54,7 @@ describe("CRUD MCP Tools", () => {
       expect(result.ref).toBeDefined();
       expect(result.status).toBe("DRAFT");
       expect(result.id).toBeDefined();
+      expect(result.dependencies).toEqual([]);
     });
 
     test("creates PRD with optional fields", async () => {
@@ -64,6 +66,17 @@ describe("CRUD MCP Tools", () => {
       expect(result.description).toBe("A description");
       expect(result.tag).toBe("mvp");
     });
+
+    test("creates PRD with depends_on", async () => {
+      const prd1 = (await createPrdTool.handler({ title: "PRD 1" })) as any;
+      const prd2 = (await createPrdTool.handler({ title: "PRD 2" })) as any;
+      const prd3 = (await createPrdTool.handler({
+        title: "PRD 3",
+        depends_on: [prd1.ref, prd2.ref],
+      })) as any;
+
+      expect(prd3.dependencies).toEqual([prd1.ref, prd2.ref]);
+    });
   });
 
   describe("create_epic", () => {
@@ -77,6 +90,7 @@ describe("CRUD MCP Tools", () => {
       expect(epic.title).toBe("Test Epic");
       expect(epic.ref).toBeDefined();
       expect(epic.status).toBe("PENDING");
+      expect(epic.dependencies).toEqual([]);
     });
 
     test("creates epic with acceptance criteria", async () => {
@@ -94,6 +108,25 @@ describe("CRUD MCP Tools", () => {
         createEpicTool.handler({ prd_ref: "INVALID-P999", title: "Test" }),
       ).rejects.toThrow("PRD not found");
     });
+
+    test("creates epic with depends_on", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+      const epic1 = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Epic 1",
+      })) as any;
+      const epic2 = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Epic 2",
+      })) as any;
+      const epic3 = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Epic 3",
+        depends_on: [epic1.ref, epic2.ref],
+      })) as any;
+
+      expect(epic3.dependencies).toEqual([epic1.ref, epic2.ref]);
+    });
   });
 
   describe("create_task", () => {
@@ -111,6 +144,7 @@ describe("CRUD MCP Tools", () => {
       expect(task.title).toBe("Test Task");
       expect(task.ref).toBeDefined();
       expect(task.priority).toBe("MEDIUM");
+      expect(task.dependencies).toEqual([]);
     });
 
     test("creates task with priority", async () => {
@@ -126,6 +160,29 @@ describe("CRUD MCP Tools", () => {
       })) as any;
       expect(task.priority).toBe("HIGH");
     });
+
+    test("creates task with depends_on", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+      const epic = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Test Epic",
+      })) as any;
+      const task1 = (await createTaskTool.handler({
+        epic_ref: epic.ref,
+        title: "Task 1",
+      })) as any;
+      const task2 = (await createTaskTool.handler({
+        epic_ref: epic.ref,
+        title: "Task 2",
+      })) as any;
+      const task3 = (await createTaskTool.handler({
+        epic_ref: epic.ref,
+        title: "Task 3",
+        depends_on: [task1.ref, task2.ref],
+      })) as any;
+
+      expect(task3.dependencies).toEqual([task1.ref, task2.ref]);
+    });
   });
 
   describe("update_entity", () => {
@@ -183,6 +240,19 @@ describe("CRUD MCP Tools", () => {
       const result = (await deleteEntityTool.handler({ ref: epic.ref })) as any;
       expect(result.cascade.tasks).toBe(2);
     });
+
+    test("cascade deletes PRD with dependencies", async () => {
+      const prd1 = (await createPrdTool.handler({ title: "PRD 1" })) as any;
+      const prd2 = (await createPrdTool.handler({ title: "PRD 2" })) as any;
+      await addDependencyTool.handler({
+        ref: prd2.ref,
+        depends_on_ref: prd1.ref,
+      });
+
+      const result = (await deleteEntityTool.handler({ ref: prd1.ref })) as any;
+      expect(result.deleted).toBe(prd1.ref);
+      expect(result.cascade.dependencies).toBe(1);
+    });
   });
 
   describe("dependencies", () => {
@@ -210,6 +280,26 @@ describe("CRUD MCP Tools", () => {
       expect(removeResult.success).toBe(true);
     });
 
+    test("adds and removes PRD dependency", async () => {
+      const prd1 = (await createPrdTool.handler({ title: "PRD 1" })) as any;
+      const prd2 = (await createPrdTool.handler({ title: "PRD 2" })) as any;
+
+      const addResult = (await addDependencyTool.handler({
+        ref: prd2.ref,
+        depends_on_ref: prd1.ref,
+      })) as any;
+      expect(addResult.success).toBe(true);
+      expect(addResult.ref).toBe(prd2.ref);
+      expect(addResult.depends_on).toBe(prd1.ref);
+
+      const removeResult = (await removeDependencyTool.handler({
+        ref: prd2.ref,
+        depends_on_ref: prd1.ref,
+      })) as any;
+      expect(removeResult.success).toBe(true);
+      expect(removeResult.removed_dependency).toBe(prd1.ref);
+    });
+
     test("prevents self-dependency", async () => {
       const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
       const epic = (await createEpicTool.handler({
@@ -221,6 +311,26 @@ describe("CRUD MCP Tools", () => {
         addDependencyTool.handler({ ref: epic.ref, depends_on_ref: epic.ref }),
       ).rejects.toThrow("depend on itself");
     });
+
+    test("prevents PRD self-dependency", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+
+      await expect(
+        addDependencyTool.handler({ ref: prd.ref, depends_on_ref: prd.ref }),
+      ).rejects.toThrow("depend on itself");
+    });
+
+    test("prevents cross-type dependencies between PRD and Epic", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+      const epic = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Epic",
+      })) as any;
+
+      await expect(
+        addDependencyTool.handler({ ref: prd.ref, depends_on_ref: epic.ref }),
+      ).rejects.toThrow("same type");
+    });
   });
 
   describe("criteria", () => {

package/src/server/tools/__tests__/mcp-interface.test.ts

@@ -3,17 +3,23 @@ import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
 // Set up test environment BEFORE any imports
-const TEST_DIR = `/tmp/flux-test-mcp-${Date.now()}`;
+const TEST_DIR = `/tmp/flux-test-mcp-${Date.now()}-${Math.random().toString(36).slice(2)}`;
 const FLUX_DIR = join(TEST_DIR, ".flux");
 process.env.FLUX_PROJECT_ROOT = TEST_DIR;
 
 import { z } from "zod";
 import { config } from "../../config.js";
 import { closeDb, initDb } from "../../db/index.js";
-import { createError, registerTools, type ToolDefinition } from "../index.js";
+import {
+  createError,
+  createProjectNotInitializedError,
+  registerTools,
+  type ToolDefinition,
+} from "../index.js";
 
 describe("MCP Interface", () => {
   beforeEach(() => {
+    closeDb();
     config.clearCache();
     process.env.FLUX_PROJECT_ROOT = TEST_DIR;
 
@@ -44,6 +50,42 @@ describe("MCP Interface", () => {
     });
   });
 
+  describe("createProjectNotInitializedError", () => {
+    test("creates error with setup instructions", () => {
+      const error = createProjectNotInitializedError("/test/cwd", "/test/root");
+
+      expect(error.error).toBe(true);
+      expect(error.code).toBe("PROJECT_NOT_INITIALIZED");
+      expect(error.message).toContain("/test/cwd");
+      expect(error.message).toContain("/test/root");
+      expect(error.setup.instructions).toBeDefined();
+      expect(error.setup.options).toHaveLength(2);
+    });
+
+    test("includes command option for interactive setup", () => {
+      const error = createProjectNotInitializedError("/cwd", "/root");
+      const commandOption = error.setup.options.find(
+        (o) => o.method === "command",
+      );
+
+      expect(commandOption).toBeDefined();
+      expect(commandOption?.name).toBe("/flux");
+      expect(commandOption?.description).toContain("Interactive");
+    });
+
+    test("includes tool option with required params", () => {
+      const error = createProjectNotInitializedError("/cwd", "/root");
+      const toolOption = error.setup.options.find((o) => o.method === "tool");
+
+      expect(toolOption).toBeDefined();
+      expect(toolOption?.name).toBe("init_project");
+      expect(toolOption?.params).toBeDefined();
+      expect(toolOption?.params?.name).toBeDefined();
+      expect(toolOption?.params?.vision).toBeDefined();
+      expect(toolOption?.params?.adapter).toBeDefined();
+    });
+  });
+
   describe("registerTools", () => {
     test("sets up list tools handler", () => {
       const handlers: Record<string, Function> = {};
@@ -287,7 +329,7 @@ describe("Project Validation", () => {
     }
   });
 
-  test("returns PROJECT_NOT_FOUND for tools requiring project", async () => {
+  test("returns PROJECT_NOT_INITIALIZED with setup instructions for tools requiring project", async () => {
     const handlers: Record<string, Function> = {};
     const mockServer = {
       setRequestHandler: mock((schema: any, handler: Function) => {
@@ -317,7 +359,11 @@ describe("Project Validation", () => {
     expect(result.isError).toBe(true);
     const parsedError = JSON.parse(result.content[0].text);
     expect(parsedError.error).toBe(true);
-    expect(parsedError.code).toBe("PROJECT_NOT_FOUND");
+    expect(parsedError.code).toBe("PROJECT_NOT_INITIALIZED");
+    expect(parsedError.setup).toBeDefined();
+    expect(parsedError.setup.instructions).toBeDefined();
+    expect(parsedError.setup.options).toBeDefined();
+    expect(parsedError.setup.options.length).toBe(2);
   });
 
   test("allows init_project without existing project", async () => {
@@ -353,7 +399,7 @@ describe("Project Validation", () => {
     expect(handlerMock).toHaveBeenCalled();
   });
 
-  test("allows get_project_context without existing project", async () => {
+  test("allows get_version without existing project", async () => {
     const handlers: Record<string, Function> = {};
     const mockServer = {
       setRequestHandler: mock((schema: any, handler: Function) => {
@@ -363,11 +409,11 @@ describe("Project Validation", () => {
       }),
     };
 
-    const handlerMock = mock(async () => ({ initialized: false }));
+    const handlerMock = mock(async () => ({ version: "1.0.0" }));
 
     const testTool: ToolDefinition = {
-      name: "get_project_context",
-      description: "Get project context",
+      name: "get_version",
+      description: "Get version",
       inputSchema: z.object({}),
       handler: handlerMock,
     };
@@ -377,7 +423,7 @@ describe("Project Validation", () => {
     const callHandler = handlers.call;
     const result = await callHandler({
       params: {
-        name: "get_project_context",
+        name: "get_version",
         arguments: {},
       },
     });
@@ -385,4 +431,49 @@ describe("Project Validation", () => {
     expect(result.isError).toBeUndefined();
     expect(handlerMock).toHaveBeenCalled();
   });
+
+  test("setup options have correct structure", async () => {
+    const handlers: Record<string, Function> = {};
+    const mockServer = {
+      setRequestHandler: mock((schema: any, handler: Function) => {
+        if (schema.shape?.method?.value === "tools/call") {
+          handlers.call = handler;
+        }
+      }),
+    };
+
+    const testTool: ToolDefinition = {
+      name: "query_entities",
+      description: "Query entities",
+      inputSchema: z.object({ type: z.string() }),
+      handler: async () => ({ items: [] }),
+    };
+
+    registerTools(mockServer as any, [testTool]);
+
+    const callHandler = handlers.call;
+    const result = await callHandler({
+      params: {
+        name: "query_entities",
+        arguments: { type: "prd" },
+      },
+    });
+
+    expect(result.isError).toBe(true);
+    const parsedError = JSON.parse(result.content[0].text);
+
+    const commandOption = parsedError.setup.options.find(
+      (o: any) => o.method === "command",
+    );
+    expect(commandOption.name).toBe("/flux");
+    expect(commandOption.description).toBeTruthy();
+
+    const toolOption = parsedError.setup.options.find(
+      (o: any) => o.method === "tool",
+    );
+    expect(toolOption.name).toBe("init_project");
+    expect(toolOption.params.name).toBeTruthy();
+    expect(toolOption.params.vision).toBeTruthy();
+    expect(toolOption.params.adapter).toBeTruthy();
+  });
 });

package/src/server/tools/__tests__/query.test.ts

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
 // Set up test environment BEFORE any imports
-const TEST_DIR = `/tmp/flux-test-query-${Date.now()}`;
+const TEST_DIR = `/tmp/flux-test-query-${Date.now()}-${Math.random().toString(36).slice(2)}`;
 const FLUX_DIR = join(TEST_DIR, ".flux");
 process.env.FLUX_PROJECT_ROOT = TEST_DIR;
 
@@ -16,13 +16,13 @@ import { createPrdTool } from "../create-prd.js";
 import { createTaskTool } from "../create-task.js";
 import { addDependencyTool } from "../dependencies.js";
 import { getEntityTool } from "../get-entity.js";
-import { getProjectContextTool } from "../get-project-context.js";
 import { getStatsTool } from "../get-stats.js";
 import { initProjectTool } from "../init-project.js";
 import { queryEntitiesTool } from "../query-entities.js";
 
 describe("Query MCP Tools", () => {
   beforeEach(() => {
+    closeDb();
     config.clearCache();
     clearAdapterCache();
     process.env.FLUX_PROJECT_ROOT = TEST_DIR;
@@ -115,6 +115,75 @@ describe("Query MCP Tools", () => {
       expect(result.dependencies[0]).toBe(epic1.ref);
     });
 
+    test("returns dependencies by default for PRD without include", async () => {
+      const prd1 = (await createPrdTool.handler({ title: "PRD 1" })) as any;
+      const prd2 = (await createPrdTool.handler({ title: "PRD 2" })) as any;
+      await addDependencyTool.handler({
+        ref: prd2.ref,
+        depends_on_ref: prd1.ref,
+      });
+
+      const result = (await getEntityTool.handler({
+        ref: prd2.ref,
+      })) as any;
+
+      expect(result.dependencies).toBeDefined();
+      expect(result.dependencies.length).toBe(1);
+      expect(result.dependencies[0]).toBe(prd1.ref);
+    });
+
+    test("returns dependencies by default for Epic without include", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+      const epic1 = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Epic 1",
+      })) as any;
+      const epic2 = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Epic 2",
+      })) as any;
+      await addDependencyTool.handler({
+        ref: epic2.ref,
+        depends_on_ref: epic1.ref,
+      });
+
+      const result = (await getEntityTool.handler({
+        ref: epic2.ref,
+      })) as any;
+
+      expect(result.dependencies).toBeDefined();
+      expect(result.dependencies.length).toBe(1);
+      expect(result.dependencies[0]).toBe(epic1.ref);
+    });
+
+    test("returns dependencies by default for Task without include", async () => {
+      const prd = (await createPrdTool.handler({ title: "Test PRD" })) as any;
+      const epic = (await createEpicTool.handler({
+        prd_ref: prd.ref,
+        title: "Test Epic",
+      })) as any;
+      const task1 = (await createTaskTool.handler({
+        epic_ref: epic.ref,
+        title: "Task 1",
+      })) as any;
+      const task2 = (await createTaskTool.handler({
+        epic_ref: epic.ref,
+        title: "Task 2",
+      })) as any;
+      await addDependencyTool.handler({
+        ref: task2.ref,
+        depends_on_ref: task1.ref,
+      });
+
+      const result = (await getEntityTool.handler({
+        ref: task2.ref,
+      })) as any;
+
+      expect(result.dependencies).toBeDefined();
+      expect(result.dependencies.length).toBe(1);
+      expect(result.dependencies[0]).toBe(task1.ref);
+    });
+
     test("throws error for invalid ref", async () => {
       await expect(
         getEntityTool.handler({ ref: "INVALID-P999" }),
@@ -242,24 +311,6 @@ describe("Query MCP Tools", () => {
     });
   });
 
-  describe("get_project_context", () => {
-    test("returns project context when initialized", async () => {
-      const result = (await getProjectContextTool.handler({})) as any;
-
-      expect(result.initialized).toBe(true);
-      expect(result.name).toBe("test-project");
-      expect(result.ref_prefix).toBe("TEST");
-    });
-
-    test("returns initialized false when no project", async () => {
-      // Remove the project.json
-      rmSync(join(FLUX_DIR, "project.json"));
-
-      const result = (await getProjectContextTool.handler({})) as any;
-      expect(result.initialized).toBe(false);
-    });
-  });
-
   describe("get_stats", () => {
     test("returns zeroes for empty project", async () => {
       const result = (await getStatsTool.handler({})) as any;
@@ -291,9 +342,10 @@ describe("Query MCP Tools", () => {
 });
 
 describe("init_project", () => {
-  const INIT_TEST_DIR = `/tmp/flux-init-test-${Date.now()}`;
+  const INIT_TEST_DIR = `/tmp/flux-init-test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
 
   beforeEach(() => {
+    closeDb();
     config.clearCache();
     clearAdapterCache();
     process.env.FLUX_PROJECT_ROOT = INIT_TEST_DIR;

package/src/server/tools/__tests__/z-configure-linear.test.ts

@@ -2,7 +2,7 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 
-const TEST_DIR = `/tmp/flux-test-${Date.now()}`;
+const TEST_DIR = `/tmp/flux-test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
 const FLUX_DIR = join(TEST_DIR, ".flux");
 process.env.FLUX_PROJECT_ROOT = TEST_DIR;
 

package/src/server/tools/__tests__/z-get-linear-url.test.ts

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
 // Set up test environment BEFORE any imports
-const TEST_DIR = `/tmp/flux-test-${Date.now()}`;
+const TEST_DIR = `/tmp/flux-test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
 const FLUX_DIR = join(TEST_DIR, ".flux");
 process.env.FLUX_PROJECT_ROOT = TEST_DIR;
 

package/src/server/tools/create-epic.ts

@@ -8,6 +8,7 @@ const inputSchema = z.object({
   title: z.string().min(1, "Title is required"),
   description: z.string().optional(),
   acceptance_criteria: z.array(z.string()).optional(),
+  depends_on: z.array(z.string()).optional(),
 });
 
 async function handler(input: unknown) {
@@ -23,13 +24,21 @@ async function handler(input: unknown) {
 
   const criteriaCount = parsed.acceptance_criteria?.length || 0;
 
-  return { ...toMcpEpic(epic), criteria_count: criteriaCount };
+  const dependencies: string[] = [];
+  if (parsed.depends_on && parsed.depends_on.length > 0) {
+    for (const depRef of parsed.depends_on) {
+      await adapter.addDependency(epic.ref, depRef);
+      dependencies.push(depRef);
+    }
+  }
+
+  return { ...toMcpEpic(epic), criteria_count: criteriaCount, dependencies };
 }
 
 export const createEpicTool: ToolDefinition = {
   name: "create_epic",
   description:
-    "Create a new Epic under a PRD. Required: prd_ref (e.g., 'FLUX-P1'), title. Optional: description, acceptance_criteria (string array). Returns {id, ref, title, status, criteria_count}. Status starts as PENDING.",
+    "Create a new Epic under a PRD. Required: prd_ref (e.g., 'FLUX-P1'), title. Optional: description, acceptance_criteria (string array), depends_on (array of Epic refs this Epic depends on, e.g., ['FLUX-E1']). Returns {id, ref, title, status, criteria_count, dependencies}. Status starts as PENDING.",
   inputSchema,
   handler,
 };

package/src/server/tools/create-prd.ts

@@ -7,6 +7,7 @@ const inputSchema = z.object({
   title: z.string().min(1, "Title is required"),
   description: z.string().optional(),
   tag: z.string().optional(),
+  depends_on: z.array(z.string()).optional(),
 });
 
 async function handler(input: unknown) {
@@ -19,13 +20,21 @@ async function handler(input: unknown) {
     tag: parsed.tag,
   });
 
-  return toMcpPrd(prd);
+  const dependencies: string[] = [];
+  if (parsed.depends_on && parsed.depends_on.length > 0) {
+    for (const depRef of parsed.depends_on) {
+      await adapter.addDependency(prd.ref, depRef);
+      dependencies.push(depRef);
+    }
+  }
+
+  return { ...toMcpPrd(prd), dependencies };
 }
 
 export const createPrdTool: ToolDefinition = {
   name: "create_prd",
   description:
-    "Create a new PRD (Product Requirements Document). Required: title. Optional: description, tag. Returns the created PRD with {id, ref, title, description, status, tag}. Status starts as DRAFT.",
+    "Create a new PRD (Product Requirements Document). Required: title. Optional: description, tag, depends_on (array of PRD refs this PRD depends on, e.g., ['FLUX-P1', 'FLUX-P2']). Returns the created PRD with {id, ref, title, description, status, tag, dependencies}. Status starts as DRAFT.",
   inputSchema,
   handler,
 };

package/src/server/tools/create-task.ts

@@ -10,6 +10,7 @@ const inputSchema = z.object({
   description: z.string().optional(),
   priority: z.enum(["LOW", "MEDIUM", "HIGH"]).optional().default("MEDIUM"),
   acceptance_criteria: z.array(z.string()).optional(),
+  depends_on: z.array(z.string()).optional(),
 });
 
 async function handler(input: unknown) {
@@ -26,13 +27,21 @@ async function handler(input: unknown) {
 
   const criteriaCount = parsed.acceptance_criteria?.length || 0;
 
-  return { ...toMcpTask(task), criteria_count: criteriaCount };
+  const dependencies: string[] = [];
+  if (parsed.depends_on && parsed.depends_on.length > 0) {
+    for (const depRef of parsed.depends_on) {
+      await adapter.addDependency(task.ref, depRef);
+      dependencies.push(depRef);
+    }
+  }
+
+  return { ...toMcpTask(task), criteria_count: criteriaCount, dependencies };
 }
 
 export const createTaskTool: ToolDefinition = {
   name: "create_task",
   description:
-    "Create a new Task under an Epic. Required: epic_ref (e.g., 'FLUX-E1'), title. Optional: description, priority (LOW|MEDIUM|HIGH, default MEDIUM), acceptance_criteria (string array). Returns {id, ref, title, status, priority, criteria_count}.",
+    "Create a new Task under an Epic. Required: epic_ref (e.g., 'FLUX-E1'), title. Optional: description, priority (LOW|MEDIUM|HIGH, default MEDIUM), acceptance_criteria (string array), depends_on (array of Task refs this Task depends on, e.g., ['FLUX-T1']). Returns {id, ref, title, status, priority, criteria_count, dependencies}.",
   inputSchema,
   handler,
 };

package/src/server/tools/dependencies.ts

@@ -41,7 +41,7 @@ async function removeDependencyHandler(input: unknown) {
 export const addDependencyTool: ToolDefinition = {
   name: "add_dependency",
   description:
-    "Add a dependency between two entities of the same type. Required: ref (depends on depends_on_ref), depends_on_ref. Both must be Epics (FLUX-E*) or both Tasks (FLUX-T*). Validates no circular dependencies. Returns {success, ref, depends_on}.",
+    "Add a dependency between two entities of the same type. Required: ref (depends on depends_on_ref), depends_on_ref. Both must be PRDs (FLUX-P*), Epics (FLUX-E*), or Tasks (FLUX-T*). Validates no circular dependencies. Returns {success, ref, depends_on}.",
   inputSchema: addDependencySchema,
   handler: addDependencyHandler,
 };
@@ -49,7 +49,7 @@ export const addDependencyTool: ToolDefinition = {
 export const removeDependencyTool: ToolDefinition = {
   name: "remove_dependency",
   description:
-    "Remove a dependency between two entities. Required: ref, depends_on_ref. Both must be same type (Epic or Task). Returns {success, ref, removed_dependency}.",
+    "Remove a dependency between two entities. Required: ref, depends_on_ref. Both must be same type (PRD, Epic, or Task). Returns {success, ref, removed_dependency}.",
   inputSchema: removeDependencySchema,
   handler: removeDependencyHandler,
 };