@projitive/mcp 2.0.4 → 2.1.1

package/output/source/tools/task.test.js

@@ -1,8 +1,22 @@
-import { describe, expect, it } from 'vitest';
-import { collectTaskLintSuggestions, isValidTaskId, normalizeTask, rankActionableTaskCandidates, resolveNoTaskDiscoveryGuidance, renderTaskSeedTemplate, renderTasksMarkdown, loadTasksDocument, saveTasks, taskPriority, toTaskUpdatedAtMs, validateTransition, } from './task.js';
+import { describe, expect, it, vi } from 'vitest';
+import { collectTaskLintSuggestions, isValidTaskId, normalizeTask, rankActionableTaskCandidates, resolveNoTaskDiscoveryGuidance, renderTaskSeedTemplate, renderTasksMarkdown, loadTasksDocument, registerTaskTools, saveTasks, taskPriority, toTaskUpdatedAtMs, validateTransition, } from './task.js';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
+import { replaceRoadmapsInStore } from '../common/store.js';
+async function createGovernanceWorkspace() {
+    const projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'projitive-mcp-task-workspace-'));
+    const governanceDir = path.join(projectRoot, '.projitive');
+    const dbPath = path.join(governanceDir, '.projitive');
+    await fs.mkdir(governanceDir, { recursive: true });
+    await fs.writeFile(dbPath, '', 'utf-8');
+    return { projectRoot, governanceDir, dbPath };
+}
+function getToolHandler(mockServer, toolName) {
+    const call = mockServer.registerTool.mock.calls.find((entry) => entry[0] === toolName);
+    expect(call).toBeTruthy();
+    return call?.[2];
+}
 function buildCandidate(partial) {
     const task = normalizeTask({
         id: partial.id,
@@ -173,4 +187,311 @@ describe('tasks module', () => {
         expect(markdown).toContain('Repository: https://github.com/yinxulai/projitive');
         await fs.rm(root, { recursive: true, force: true });
     });
+    it('taskCreate auto-generates the next task id and syncs tasks view', async () => {
+        const { projectRoot, governanceDir, dbPath } = await createGovernanceWorkspace();
+        await replaceRoadmapsInStore(dbPath, [
+            { id: 'ROADMAP-0001', title: 'Bootstrap', status: 'active', updatedAt: '2026-03-14T00:00:00.000Z' },
+        ]);
+        await saveTasks(dbPath, [
+            normalizeTask({ id: 'TASK-0009', title: 'existing', status: 'TODO', roadmapRefs: ['ROADMAP-0001'] }),
+        ]);
+        const mockServer = { registerTool: vi.fn() };
+        registerTaskTools(mockServer);
+        const taskCreate = getToolHandler(mockServer, 'taskCreate');
+        const result = await taskCreate({
+            projectPath: projectRoot,
+            title: 'newly generated',
+            summary: 'auto id test',
+            roadmapRefs: ['ROADMAP-0001'],
+        });
+        expect(result.isError).toBeUndefined();
+        expect(result.content[0].text).toContain('TASK-0010');
+        const loaded = await loadTasksDocument(governanceDir);
+        expect(loaded.tasks.some((task) => task.id === 'TASK-0010' && task.title === 'newly generated')).toBe(true);
+        await fs.rm(projectRoot, { recursive: true, force: true });
+    });
+    it('taskUpdate rejects invalid status transitions', async () => {
+        const { projectRoot, dbPath } = await createGovernanceWorkspace();
+        await saveTasks(dbPath, [
+            normalizeTask({ id: 'TASK-0001', title: 'done task', status: 'DONE' }),
+        ]);
+        const mockServer = { registerTool: vi.fn() };
+        registerTaskTools(mockServer);
+        const taskUpdate = getToolHandler(mockServer, 'taskUpdate');
+        const result = await taskUpdate({
+            projectPath: projectRoot,
+            taskId: 'TASK-0001',
+            updates: { status: 'IN_PROGRESS' },
+        });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain('Invalid status transition');
+        await fs.rm(projectRoot, { recursive: true, force: true });
+    });
+    it('taskNext emits no-actionable guidance when only blocked tasks exist', async () => {
+        const { projectRoot, dbPath } = await createGovernanceWorkspace();
+        await replaceRoadmapsInStore(dbPath, [
+            { id: 'ROADMAP-0001', title: 'Blocked milestone', status: 'active', updatedAt: '2026-03-14T00:00:00.000Z' },
+        ]);
+        await saveTasks(dbPath, [
+            normalizeTask({
+                id: 'TASK-0001',
+                title: 'blocked task',
+                status: 'BLOCKED',
+                summary: 'waiting',
+                roadmapRefs: ['ROADMAP-0001'],
+            }),
+        ]);
+        vi.stubEnv('PROJITIVE_SCAN_ROOT_PATHS', projectRoot);
+        vi.stubEnv('PROJITIVE_SCAN_MAX_DEPTH', '3');
+        const mockServer = { registerTool: vi.fn() };
+        registerTaskTools(mockServer);
+        const taskNext = getToolHandler(mockServer, 'taskNext');
+        const result = await taskNext({});
+        expect(result.content[0].text).toContain('No TODO/IN_PROGRESS task is available.');
+        expect(result.content[0].text).toContain('No-Task Discovery Checklist');
+        expect(result.content[0].text).toContain('taskCreate(projectPath=');
+        vi.unstubAllEnvs();
+        await fs.rm(projectRoot, { recursive: true, force: true });
+    });
+    it('taskList and taskContext expose synced views and evidence for an existing task', async () => {
+        const { projectRoot, governanceDir, dbPath } = await createGovernanceWorkspace();
+        await replaceRoadmapsInStore(dbPath, [
+            { id: 'ROADMAP-0001', title: 'Roadmap', status: 'active', updatedAt: '2026-03-14T00:00:00.000Z' },
+        ]);
+        await fs.writeFile(path.join(projectRoot, 'README.md'), '# Root Readme\nTASK-0001\n', 'utf-8');
+        await saveTasks(dbPath, [
+            normalizeTask({
+                id: 'TASK-0001',
+                title: 'inspect me',
+                status: 'IN_PROGRESS',
+                owner: 'copilot',
+                summary: 'has evidence',
+                roadmapRefs: ['ROADMAP-0001'],
+                links: ['README.md'],
+            }),
+        ]);
+        const mockServer = { registerTool: vi.fn() };
+        registerTaskTools(mockServer);
+        const taskList = getToolHandler(mockServer, 'taskList');
+        const listResult = await taskList({ projectPath: projectRoot, status: 'IN_PROGRESS' });
+        expect(listResult.content[0].text).toContain(`tasksView: ${path.join(governanceDir, 'tasks.md')}`);
+        expect(listResult.content[0].text).toContain('TASK-0001 | IN_PROGRESS | inspect me');
+        const taskContext = getToolHandler(mockServer, 'taskContext');
+        const contextResult = await taskContext({ projectPath: projectRoot, taskId: 'TASK-0001' });
+        expect(contextResult.content[0].text).toContain(`roadmapView: ${path.join(governanceDir, 'roadmap.md')}`);
+        expect(contextResult.content[0].text).toContain('### Reference Locations');
+        expect(contextResult.content[0].text).toContain('README.md');
+        expect(contextResult.content[0].text).toContain('### Pre-Execution Research Brief');
+        expect(contextResult.content[0].text).toContain('researchBriefStatus: MISSING');
+        expect(contextResult.content[0].text).toContain('designs/research/TASK-0001.implementation-research.md');
+        expect(contextResult.content[0].text).toContain('architectureDocsStatus: MISSING');
+        expect(contextResult.content[0].text).toContain('styleDocsStatus: MISSING');
+        expect(contextResult.content[0].text).toContain('Project context docs gate is NOT satisfied');
+        expect(contextResult.content[0].text).toContain('PROJECT_ARCHITECTURE_DOC_MISSING');
+        expect(contextResult.content[0].text).toContain('PROJECT_STYLE_DOC_MISSING');
+        await fs.rm(projectRoot, { recursive: true, force: true });
+    });
+    it('taskUpdate allows TODO -> IN_PROGRESS when research brief is missing, with lint guidance', async () => {
+        const { projectRoot, dbPath } = await createGovernanceWorkspace();
+        await replaceRoadmapsInStore(dbPath, [
+            { id: 'ROADMAP-0001', title: 'Bootstrap', status: 'active', updatedAt: '2026-03-14T00:00:00.000Z' },
+        ]);
+        await saveTasks(dbPath, [
+            normalizeTask({ id: 'TASK-0001', title: 'gate test', status: 'TODO', roadmapRefs: ['ROADMAP-0001'] }),
+        ]);
+        const mockServer = { registerTool: vi.fn() };
+        registerTaskTools(mockServer);
+        const taskUpdate = getToolHandler(mockServer, 'taskUpdate');
+        const result = await taskUpdate({
+            projectPath: projectRoot,
+            taskId: 'TASK-0001',
+            updates: { status: 'IN_PROGRESS' },
+        });
+        expect(result.isError).toBeUndefined();
+        expect(result.content[0].text).toContain('newStatus: IN_PROGRESS');
+        expect(result.content[0].text).toContain('TASK_RESEARCH_BRIEF_MISSING');
+        await fs.rm(projectRoot, { recursive: true, force: true });
+    });
+    it('taskUpdate allows TODO -> IN_PROGRESS when research brief is ready', async () => {
+        const { projectRoot, dbPath } = await createGovernanceWorkspace();
+        await replaceRoadmapsInStore(dbPath, [
+            { id: 'ROADMAP-0001', title: 'Bootstrap', status: 'active', updatedAt: '2026-03-14T00:00:00.000Z' },
+        ]);
+        await saveTasks(dbPath, [
+            normalizeTask({ id: 'TASK-0001', title: 'gate test pass', status: 'TODO', roadmapRefs: ['ROADMAP-0001'] }),
+        ]);
+        const researchDir = path.join(projectRoot, 'designs', 'research');
+        await fs.mkdir(researchDir, { recursive: true });
+        await fs.writeFile(path.join(researchDir, 'TASK-0001.implementation-research.md'), [
+            '# TASK-0001 Implementation Research Brief',
+            '',
+            '## Design Guidelines and Specs',
+            '- designs/PROJITIVE.md#L10-L20',
+            '',
+            '## Code Architecture and Implementation Findings',
+            '- packages/mcp/source/tools/task.ts#L1-L50',
+        ].join('\n'), 'utf-8');
+        const mockServer = { registerTool: vi.fn() };
+        registerTaskTools(mockServer);
+        const taskUpdate = getToolHandler(mockServer, 'taskUpdate');
+        const result = await taskUpdate({
+            projectPath: projectRoot,
+            taskId: 'TASK-0001',
+            updates: { status: 'IN_PROGRESS' },
+        });
+        expect(result.isError).toBeUndefined();
+        expect(result.content[0].text).toContain('newStatus: IN_PROGRESS');
+        await fs.rm(projectRoot, { recursive: true, force: true });
+    });
+    it('taskContext requires project core docs under designs/core (docs outside core do not satisfy)', async () => {
+        const { projectRoot, dbPath } = await createGovernanceWorkspace();
+        await replaceRoadmapsInStore(dbPath, [
+            { id: 'ROADMAP-0001', title: 'Roadmap', status: 'active', updatedAt: '2026-03-14T00:00:00.000Z' },
+        ]);
+        await saveTasks(dbPath, [
+            normalizeTask({ id: 'TASK-0001', title: 'core docs rule', status: 'TODO', roadmapRefs: ['ROADMAP-0001'] }),
+        ]);
+        await fs.mkdir(path.join(projectRoot, 'designs'), { recursive: true });
+        await fs.writeFile(path.join(projectRoot, 'designs', 'architecture.md'), '# Architecture\n', 'utf-8');
+        await fs.writeFile(path.join(projectRoot, 'designs', 'style-guide.md'), '# Style\n', 'utf-8');
+        const mockServer = { registerTool: vi.fn() };
+        registerTaskTools(mockServer);
+        const taskContext = getToolHandler(mockServer, 'taskContext');
+        const contextResult = await taskContext({ projectPath: projectRoot, taskId: 'TASK-0001' });
+        expect(contextResult.content[0].text).toContain('architectureDocsStatus: MISSING');
+        expect(contextResult.content[0].text).toContain('styleDocsStatus: MISSING');
+        expect(contextResult.content[0].text).toContain('designs/core/architecture.md');
+        expect(contextResult.content[0].text).toContain('PROJECT_ARCHITECTURE_DOC_MISSING');
+        expect(contextResult.content[0].text).toContain('PROJECT_STYLE_DOC_MISSING');
+        await fs.rm(projectRoot, { recursive: true, force: true });
+    });
+    it('taskContext marks project core docs ready when architecture/style docs exist under designs/core', async () => {
+        const { projectRoot, governanceDir, dbPath } = await createGovernanceWorkspace();
+        await replaceRoadmapsInStore(dbPath, [
+            { id: 'ROADMAP-0001', title: 'Roadmap', status: 'active', updatedAt: '2026-03-14T00:00:00.000Z' },
+        ]);
+        await saveTasks(dbPath, [
+            normalizeTask({ id: 'TASK-0001', title: 'core docs ready', status: 'TODO', roadmapRefs: ['ROADMAP-0001'] }),
+        ]);
+        const coreDir = path.join(governanceDir, 'designs', 'core');
+        await fs.mkdir(coreDir, { recursive: true });
+        await fs.writeFile(path.join(coreDir, 'architecture.md'), '# Architecture\n', 'utf-8');
+        await fs.writeFile(path.join(coreDir, 'style-guide.md'), '# Style\n', 'utf-8');
+        const mockServer = { registerTool: vi.fn() };
+        registerTaskTools(mockServer);
+        const taskContext = getToolHandler(mockServer, 'taskContext');
+        const contextResult = await taskContext({ projectPath: projectRoot, taskId: 'TASK-0001' });
+        expect(contextResult.content[0].text).toContain('architectureDocsStatus: READY');
+        expect(contextResult.content[0].text).toContain('styleDocsStatus: READY');
+        expect(contextResult.content[0].text).toContain('Project context docs gate satisfied');
+        await fs.rm(projectRoot, { recursive: true, force: true });
+    });
+    it('taskContext requires fixed core doc filenames even under designs/core', async () => {
+        const { projectRoot, governanceDir, dbPath } = await createGovernanceWorkspace();
+        await replaceRoadmapsInStore(dbPath, [
+            { id: 'ROADMAP-0001', title: 'Roadmap', status: 'active', updatedAt: '2026-03-14T00:00:00.000Z' },
+        ]);
+        await saveTasks(dbPath, [
+            normalizeTask({ id: 'TASK-0001', title: 'fixed filename rule', status: 'TODO', roadmapRefs: ['ROADMAP-0001'] }),
+        ]);
+        const coreDir = path.join(governanceDir, 'designs', 'core');
+        await fs.mkdir(coreDir, { recursive: true });
+        await fs.writeFile(path.join(coreDir, 'system-architecture.md'), '# Architecture\n', 'utf-8');
+        await fs.writeFile(path.join(coreDir, 'visual-style.md'), '# Style\n', 'utf-8');
+        const mockServer = { registerTool: vi.fn() };
+        registerTaskTools(mockServer);
+        const taskContext = getToolHandler(mockServer, 'taskContext');
+        const contextResult = await taskContext({ projectPath: projectRoot, taskId: 'TASK-0001' });
+        expect(contextResult.content[0].text).toContain('architectureDocsStatus: MISSING');
+        expect(contextResult.content[0].text).toContain('styleDocsStatus: MISSING');
+        expect(contextResult.content[0].text).toContain('add required file designs/core/architecture.md');
+        expect(contextResult.content[0].text).toContain('add required file designs/core/style-guide.md');
+        await fs.rm(projectRoot, { recursive: true, force: true });
+    });
+    it('taskUpdate allows IN_PROGRESS -> DONE with lint guidance when conformance fails', async () => {
+        const { projectRoot, governanceDir, dbPath } = await createGovernanceWorkspace();
+        await replaceRoadmapsInStore(dbPath, [
+            { id: 'ROADMAP-0001', title: 'Roadmap', status: 'active', updatedAt: '2026-03-14T00:00:00.000Z' },
+        ]);
+        await saveTasks(dbPath, [
+            normalizeTask({
+                id: 'TASK-0001',
+                title: 'done gate fail',
+                status: 'IN_PROGRESS',
+                owner: 'ai-copilot',
+                roadmapRefs: ['ROADMAP-0001'],
+                links: [],
+            }),
+        ]);
+        const researchDir = path.join(projectRoot, 'designs', 'research');
+        await fs.mkdir(researchDir, { recursive: true });
+        await fs.writeFile(path.join(researchDir, 'TASK-0001.implementation-research.md'), [
+            '# TASK-0001 Implementation Research Brief',
+            '',
+            '## Design Guidelines and Specs',
+            '- designs/core/architecture.md#L1',
+            '',
+            '## Code Architecture and Implementation Findings',
+            '- packages/mcp/source/tools/task.ts#L1',
+        ].join('\n'), 'utf-8');
+        const coreDir = path.join(governanceDir, 'designs', 'core');
+        await fs.mkdir(coreDir, { recursive: true });
+        await fs.writeFile(path.join(coreDir, 'architecture.md'), '# Architecture\n', 'utf-8');
+        await fs.writeFile(path.join(coreDir, 'style-guide.md'), '# Style\n', 'utf-8');
+        const mockServer = { registerTool: vi.fn() };
+        registerTaskTools(mockServer);
+        const taskUpdate = getToolHandler(mockServer, 'taskUpdate');
+        const result = await taskUpdate({
+            projectPath: projectRoot,
+            taskId: 'TASK-0001',
+            updates: { status: 'DONE' },
+        });
+        expect(result.isError).toBeUndefined();
+        expect(result.content[0].text).toContain('newStatus: DONE');
+        expect(result.content[0].text).toContain('TASK_DONE_LINKS_MISSING');
+        await fs.rm(projectRoot, { recursive: true, force: true });
+    });
+    it('taskUpdate allows IN_PROGRESS -> DONE when conformance re-check passes', async () => {
+        const { projectRoot, governanceDir, dbPath } = await createGovernanceWorkspace();
+        await replaceRoadmapsInStore(dbPath, [
+            { id: 'ROADMAP-0001', title: 'Roadmap', status: 'active', updatedAt: '2026-03-14T00:00:00.000Z' },
+        ]);
+        await fs.writeFile(path.join(projectRoot, 'README.md'), '# Evidence\n', 'utf-8');
+        await saveTasks(dbPath, [
+            normalizeTask({
+                id: 'TASK-0001',
+                title: 'done gate pass',
+                status: 'IN_PROGRESS',
+                owner: 'ai-copilot',
+                roadmapRefs: ['ROADMAP-0001'],
+                links: ['README.md'],
+            }),
+        ]);
+        const researchDir = path.join(projectRoot, 'designs', 'research');
+        await fs.mkdir(researchDir, { recursive: true });
+        await fs.writeFile(path.join(researchDir, 'TASK-0001.implementation-research.md'), [
+            '# TASK-0001 Implementation Research Brief',
+            '',
+            '## Design Guidelines and Specs',
+            '- designs/core/architecture.md#L1',
+            '',
+            '## Code Architecture and Implementation Findings',
+            '- packages/mcp/source/tools/task.ts#L1',
+        ].join('\n'), 'utf-8');
+        const coreDir = path.join(governanceDir, 'designs', 'core');
+        await fs.mkdir(coreDir, { recursive: true });
+        await fs.writeFile(path.join(coreDir, 'architecture.md'), '# Architecture\n', 'utf-8');
+        await fs.writeFile(path.join(coreDir, 'style-guide.md'), '# Style\n', 'utf-8');
+        const mockServer = { registerTool: vi.fn() };
+        registerTaskTools(mockServer);
+        const taskUpdate = getToolHandler(mockServer, 'taskUpdate');
+        const result = await taskUpdate({
+            projectPath: projectRoot,
+            taskId: 'TASK-0001',
+            updates: { status: 'DONE' },
+        });
+        expect(result.isError).toBeUndefined();
+        expect(result.content[0].text).toContain('newStatus: DONE');
+        await fs.rm(projectRoot, { recursive: true, force: true });
+    });
 });

package/output/source/types.js

@@ -45,4 +45,10 @@ export const TASK_LINT_CODES = {
     IN_PROGRESS_WITHOUT_SUBSTATE: 'TASK_IN_PROGRESS_WITHOUT_SUBSTATE',
     SUBSTATE_PHASE_INVALID: 'TASK_SUBSTATE_PHASE_INVALID',
     SUBSTATE_CONFIDENCE_INVALID: 'TASK_SUBSTATE_CONFIDENCE_INVALID',
+    RESEARCH_BRIEF_MISSING: 'TASK_RESEARCH_BRIEF_MISSING',
+    RESEARCH_BRIEF_INCOMPLETE: 'TASK_RESEARCH_BRIEF_INCOMPLETE',
+};
+export const PROJECT_LINT_CODES = {
+    ARCHITECTURE_DOC_MISSING: 'PROJECT_ARCHITECTURE_DOC_MISSING',
+    STYLE_DOC_MISSING: 'PROJECT_STYLE_DOC_MISSING',
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projitive/mcp",
-  "version": "2.0.4",
+  "version": "2.1.1",
   "description": "Projitive MCP Server for project and task discovery/update",
   "license": "ISC",
   "author": "",