@projitive/mcp 2.0.3 → 2.1.0

package/output/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@projitive/mcp",
-    "version": "2.0.3",
+    "version": "2.1.0",
     "description": "Projitive MCP Server for project and task discovery/update",
     "license": "ISC",
     "author": "",
@@ -16,7 +16,9 @@
         "test": "vitest run",
         "test:coverage": "vitest run --coverage",
         "benchmark": "vitest bench --run",
-        "lint": "tsc -p tsconfig.json --noEmit",
+        "lint": "npm run lint:types && npm run lint:eslint",
+        "lint:types": "tsc -p tsconfig.json --noEmit",
+        "lint:eslint": "eslint .",
         "build": "rm -rf output && tsc -p tsconfig.json",
         "prepublishOnly": "npm run build",
         "dev": "tsc -p tsconfig.json --watch"
@@ -31,8 +33,12 @@
     "devDependencies": {
         "@types/node": "^24.3.0",
         "@vitest/coverage-v8": "^3.2.4",
+        "@eslint/js": "^9.37.0",
+        "eslint": "^9.37.0",
+        "globals": "^16.4.0",
         "tsx": "^4.20.5",
         "typescript": "^5.9.2",
+        "typescript-eslint": "^8.45.0",
         "vitest": "^3.2.4"
     }
 }

package/output/source/common/artifacts.js

@@ -2,7 +2,7 @@ export function candidateFilesFromArtifacts(artifacts) {
     return artifacts
         .filter((item) => item.exists)
         .flatMap((item) => {
-        if (item.kind === "file") {
+        if (item.kind === 'file') {
             return [item.path];
         }
         return (item.markdownFiles ?? []).map((entry) => entry.path);

package/output/source/common/artifacts.test.js

@@ -1,18 +1,18 @@
-import { describe, expect, it } from "vitest";
-import { candidateFilesFromArtifacts } from "./artifacts.js";
-describe("candidateFilesFromArtifacts", () => {
-    it("collects existing file artifacts and markdown files from existing directories", () => {
+import { describe, expect, it } from 'vitest';
+import { candidateFilesFromArtifacts } from './artifacts.js';
+describe('candidateFilesFromArtifacts', () => {
+    it('collects existing file artifacts and markdown files from existing directories', () => {
         const candidates = candidateFilesFromArtifacts([
-            { name: "README.md", kind: "file", path: "/a/README.md", exists: true, lineCount: 3 },
-            { name: "tasks.md", kind: "file", path: "/a/tasks.md", exists: false },
+            { name: 'README.md', kind: 'file', path: '/a/README.md', exists: true, lineCount: 3 },
+            { name: 'tasks.md', kind: 'file', path: '/a/tasks.md', exists: false },
             {
-                name: "designs",
-                kind: "directory",
-                path: "/a/designs",
+                name: 'designs',
+                kind: 'directory',
+                path: '/a/designs',
                 exists: true,
-                markdownFiles: [{ path: "/a/designs/d1.md", lineCount: 10 }],
+                markdownFiles: [{ path: '/a/designs/d1.md', lineCount: 10 }],
             },
         ]);
-        expect(candidates).toEqual(["/a/README.md", "/a/designs/d1.md"]);
+        expect(candidates).toEqual(['/a/README.md', '/a/designs/d1.md']);
     });
 });

package/output/source/common/errors.js

@@ -6,49 +6,49 @@ export class ProjitiveError extends Error {
         super(message);
         this.code = code;
         this.details = details;
-        this.name = "ProjitiveError";
+        this.name = 'ProjitiveError';
     }
 }
 // Project related errors
 export class ProjectError extends ProjitiveError {
     constructor(message, code, details) {
         super(message, code, details);
-        this.name = "ProjectError";
+        this.name = 'ProjectError';
     }
 }
 export class ProjectNotFoundError extends ProjectError {
     constructor(inputPath) {
-        super(`Project not found at path: ${inputPath}`, "PROJECT_NOT_FOUND", {
+        super(`Project not found at path: ${inputPath}`, 'PROJECT_NOT_FOUND', {
             inputPath,
         });
     }
 }
 export class GovernanceRootNotFoundError extends ProjectError {
     constructor(projectPath) {
-        super(`Governance root not found for project: ${projectPath}`, "GOVERNANCE_ROOT_NOT_FOUND", { projectPath });
+        super(`Governance root not found for project: ${projectPath}`, 'GOVERNANCE_ROOT_NOT_FOUND', { projectPath });
     }
 }
 // Task related errors
 export class TaskError extends ProjitiveError {
     constructor(message, code, details) {
         super(message, code, details);
-        this.name = "TaskError";
+        this.name = 'TaskError';
     }
 }
 export class TaskNotFoundError extends TaskError {
     constructor(taskId) {
-        super(`Task not found: ${taskId}`, "TASK_NOT_FOUND", { taskId });
+        super(`Task not found: ${taskId}`, 'TASK_NOT_FOUND', { taskId });
     }
 }
 export class InvalidTaskIdError extends TaskError {
     constructor(taskId) {
-        super(`Invalid task ID: ${taskId}`, "INVALID_TASK_ID", { taskId });
+        super(`Invalid task ID: ${taskId}`, 'INVALID_TASK_ID', { taskId });
     }
 }
 export class TaskValidationError extends TaskError {
     errors;
     constructor(taskId, errors) {
-        super(`Task validation failed for ${taskId}: ${errors.join(", ")}`, "TASK_VALIDATION_FAILED", { taskId, errors });
+        super(`Task validation failed for ${taskId}: ${errors.join(', ')}`, 'TASK_VALIDATION_FAILED', { taskId, errors });
         this.errors = errors;
     }
 }
@@ -56,26 +56,26 @@ export class TaskValidationError extends TaskError {
 export class FileError extends ProjitiveError {
     filePath;
     constructor(message, filePath, code, details) {
-        super(message, code || "FILE_ERROR", { filePath, ...details });
+        super(message, code || 'FILE_ERROR', { filePath, ...details });
         this.filePath = filePath;
-        this.name = "FileError";
+        this.name = 'FileError';
     }
 }
 export class FileNotFoundError extends FileError {
     constructor(filePath) {
-        super(`File not found: ${filePath}`, filePath, "FILE_NOT_FOUND");
+        super(`File not found: ${filePath}`, filePath, 'FILE_NOT_FOUND');
     }
 }
 export class FileReadError extends FileError {
     constructor(filePath, cause) {
-        super(`Failed to read file: ${filePath}`, filePath, "FILE_READ_ERROR", {
+        super(`Failed to read file: ${filePath}`, filePath, 'FILE_READ_ERROR', {
             cause: cause?.message,
         });
     }
 }
 export class FileWriteError extends FileError {
     constructor(filePath, cause) {
-        super(`Failed to write file: ${filePath}`, filePath, "FILE_WRITE_ERROR", {
+        super(`Failed to write file: ${filePath}`, filePath, 'FILE_WRITE_ERROR', {
             cause: cause?.message,
         });
     }
@@ -84,15 +84,15 @@ export class FileWriteError extends FileError {
 export class ValidationError extends ProjitiveError {
     errors;
     constructor(message, errors = [], code) {
-        super(message, code || "VALIDATION_FAILED", { errors });
+        super(message, code || 'VALIDATION_FAILED', { errors });
         this.errors = errors;
-        this.name = "ValidationError";
+        this.name = 'ValidationError';
     }
 }
 export class ConfidenceScoreError extends ValidationError {
     score;
     constructor(message, score, errors = []) {
-        super(message, errors, "CONFIDENCE_SCORE_ERROR");
+        super(message, errors, 'CONFIDENCE_SCORE_ERROR');
         this.score = score;
         this.score = score;
     }
@@ -101,19 +101,19 @@ export class ConfidenceScoreError extends ValidationError {
 export class MCPError extends ProjitiveError {
     constructor(message, code, details) {
         super(message, code, details);
-        this.name = "MCPError";
+        this.name = 'MCPError';
     }
 }
 export class ResourceNotFoundError extends MCPError {
     constructor(resourceUri) {
-        super(`Resource not found: ${resourceUri}`, "RESOURCE_NOT_FOUND", {
+        super(`Resource not found: ${resourceUri}`, 'RESOURCE_NOT_FOUND', {
             resourceUri,
         });
     }
 }
 export class PromptNotFoundError extends MCPError {
     constructor(promptName) {
-        super(`Prompt not found: ${promptName}`, "PROMPT_NOT_FOUND", {
+        super(`Prompt not found: ${promptName}`, 'PROMPT_NOT_FOUND', {
             promptName,
         });
     }

package/output/source/common/errors.test.js

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+import { ConfidenceScoreError, FileNotFoundError, FileReadError, FileWriteError, GovernanceRootNotFoundError, InvalidTaskIdError, MCPError, ProjectError, ProjectNotFoundError, PromptNotFoundError, ProjitiveError, ResourceNotFoundError, TaskError, TaskNotFoundError, TaskValidationError, ValidationError, } from './errors.js';
+describe('errors module', () => {
+    it('constructs base and project/task hierarchy errors with metadata', () => {
+        const base = new ProjitiveError('base failure', 'BASE', { a: 1 });
+        const project = new ProjectError('project failure', 'PROJECT', { projectPath: '/tmp/project' });
+        const task = new TaskError('task failure', 'TASK', { taskId: 'TASK-0001' });
+        expect(base.name).toBe('ProjitiveError');
+        expect(base.code).toBe('BASE');
+        expect(base.details).toEqual({ a: 1 });
+        expect(project.name).toBe('ProjectError');
+        expect(project.code).toBe('PROJECT');
+        expect(task.name).toBe('TaskError');
+        expect(task.code).toBe('TASK');
+    });
+    it('constructs specific project and task lookup errors', () => {
+        const projectNotFound = new ProjectNotFoundError('/tmp/missing');
+        const governanceNotFound = new GovernanceRootNotFoundError('/tmp/project');
+        const taskNotFound = new TaskNotFoundError('TASK-0001');
+        const invalidTaskId = new InvalidTaskIdError('BAD');
+        const taskValidation = new TaskValidationError('TASK-0001', ['owner required', 'links required']);
+        expect(projectNotFound.code).toBe('PROJECT_NOT_FOUND');
+        expect(projectNotFound.message).toContain('/tmp/missing');
+        expect(governanceNotFound.code).toBe('GOVERNANCE_ROOT_NOT_FOUND');
+        expect(taskNotFound.code).toBe('TASK_NOT_FOUND');
+        expect(invalidTaskId.code).toBe('INVALID_TASK_ID');
+        expect(taskValidation.code).toBe('TASK_VALIDATION_FAILED');
+        expect(taskValidation.errors).toEqual(['owner required', 'links required']);
+        expect(taskValidation.message).toContain('owner required, links required');
+    });
+    it('constructs file and validation related errors', () => {
+        const cause = new Error('disk offline');
+        const notFound = new FileNotFoundError('/tmp/a.md');
+        const readError = new FileReadError('/tmp/b.md', cause);
+        const writeError = new FileWriteError('/tmp/c.md', cause);
+        const validation = new ValidationError('invalid input', ['field missing']);
+        const confidence = new ConfidenceScoreError('bad confidence', 1.5, ['must be <= 1']);
+        expect(notFound.name).toBe('FileError');
+        expect(notFound.code).toBe('FILE_NOT_FOUND');
+        expect(readError.details).toMatchObject({ filePath: '/tmp/b.md', cause: 'disk offline' });
+        expect(writeError.details).toMatchObject({ filePath: '/tmp/c.md', cause: 'disk offline' });
+        expect(validation.name).toBe('ValidationError');
+        expect(validation.code).toBe('VALIDATION_FAILED');
+        expect(validation.errors).toEqual(['field missing']);
+        expect(confidence.code).toBe('CONFIDENCE_SCORE_ERROR');
+        expect(confidence.score).toBe(1.5);
+    });
+    it('constructs MCP related not-found errors', () => {
+        const mcp = new MCPError('mcp failed', 'MCP_GENERIC', { retry: true });
+        const resource = new ResourceNotFoundError('projitive://missing');
+        const prompt = new PromptNotFoundError('taskExecution');
+        expect(mcp.name).toBe('MCPError');
+        expect(mcp.details).toEqual({ retry: true });
+        expect(resource.code).toBe('RESOURCE_NOT_FOUND');
+        expect(resource.message).toContain('projitive://missing');
+        expect(prompt.code).toBe('PROMPT_NOT_FOUND');
+        expect(prompt.message).toContain('taskExecution');
+    });
+});

package/output/source/common/files.js

@@ -1,26 +1,37 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { catchIt } from "./catch.js";
-const FILE_ARTIFACTS = ["README.md", "roadmap.md", "tasks.md"];
-const DIRECTORY_ARTIFACTS = ["designs", "reports", "templates"];
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { catchIt } from './catch.js';
+const FILE_ARTIFACTS = ['README.md', 'roadmap.md', 'tasks.md'];
+const DIRECTORY_ARTIFACTS = ['designs', 'reports', 'templates'];
 async function fileLineCount(filePath) {
-    const content = await fs.readFile(filePath, "utf-8");
+    const content = await fs.readFile(filePath, 'utf-8');
     if (!content) {
         return 0;
     }
     return content.split(/\r?\n/).length;
 }
 async function listMarkdownFiles(dirPath) {
-    const entriesResult = await catchIt(fs.readdir(dirPath, { withFileTypes: true }));
-    if (entriesResult.isError()) {
-        return [];
-    }
-    const entries = entriesResult.value;
-    const files = entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".md"));
     const result = [];
-    for (const file of files) {
-        const fullPath = path.join(dirPath, file.name);
-        result.push({ path: fullPath, lineCount: await fileLineCount(fullPath) });
+    const stack = [dirPath];
+    while (stack.length > 0) {
+        const currentDir = stack.pop();
+        if (!currentDir) {
+            continue;
+        }
+        const entriesResult = await catchIt(fs.readdir(currentDir, { withFileTypes: true }));
+        if (entriesResult.isError()) {
+            continue;
+        }
+        for (const entry of entriesResult.value) {
+            const entryPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(entryPath);
+                continue;
+            }
+            if (entry.isFile() && entry.name.toLowerCase().endsWith('.md')) {
+                result.push({ path: entryPath, lineCount: await fileLineCount(entryPath) });
+            }
+        }
     }
     return result.sort((a, b) => a.path.localeCompare(b.path));
 }
@@ -32,14 +43,14 @@ export async function discoverGovernanceArtifacts(governanceDir) {
         if (!accessResult.isError()) {
             result.push({
                 name: artifact,
-                kind: "file",
+                kind: 'file',
                 path: artifactPath,
                 exists: true,
                 lineCount: await fileLineCount(artifactPath),
             });
         }
         else {
-            result.push({ name: artifact, kind: "file", path: artifactPath, exists: false });
+            result.push({ name: artifact, kind: 'file', path: artifactPath, exists: false });
         }
     }
     for (const artifact of DIRECTORY_ARTIFACTS) {
@@ -48,14 +59,14 @@ export async function discoverGovernanceArtifacts(governanceDir) {
         if (!accessResult.isError()) {
             result.push({
                 name: artifact,
-                kind: "directory",
+                kind: 'directory',
                 path: artifactPath,
                 exists: true,
                 markdownFiles: await listMarkdownFiles(artifactPath),
             });
         }
         else {
-            result.push({ name: artifact, kind: "directory", path: artifactPath, exists: false, markdownFiles: [] });
+            result.push({ name: artifact, kind: 'directory', path: artifactPath, exists: false, markdownFiles: [] });
         }
     }
     return result;

package/output/source/common/files.test.js

@@ -1,11 +1,11 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
 import { discoverGovernanceArtifacts } from './files.js';
 const tempPaths = [];
 async function createTempDir() {
-    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "projitive-mcp-test-"));
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'projitive-mcp-test-'));
     tempPaths.push(dir);
     return dir;
 }
@@ -14,19 +14,19 @@ afterEach(async () => {
         await fs.rm(dir, { recursive: true, force: true });
     }));
 });
-describe("files module", () => {
-    it("discovers governance artifacts with paths and line counts", async () => {
+describe('files module', () => {
+    it('discovers governance artifacts with paths and line counts', async () => {
         const root = await createTempDir();
-        await fs.writeFile(path.join(root, "README.md"), "# Readme\n", "utf-8");
-        await fs.writeFile(path.join(root, "tasks.md"), "# Tasks\n## TODO\n", "utf-8");
-        await fs.mkdir(path.join(root, "designs"), { recursive: true });
-        await fs.writeFile(path.join(root, "designs", "feature-design.md"), "# Design\n", "utf-8");
+        await fs.writeFile(path.join(root, 'README.md'), '# Readme\n', 'utf-8');
+        await fs.writeFile(path.join(root, 'tasks.md'), '# Tasks\n## TODO\n', 'utf-8');
+        await fs.mkdir(path.join(root, 'designs'), { recursive: true });
+        await fs.writeFile(path.join(root, 'designs', 'feature-design.md'), '# Design\n', 'utf-8');
         const artifacts = await discoverGovernanceArtifacts(root);
-        const readme = artifacts.find((item) => item.name === "README.md");
-        const designs = artifacts.find((item) => item.name === "designs");
+        const readme = artifacts.find((item) => item.name === 'README.md');
+        const designs = artifacts.find((item) => item.name === 'designs');
         expect(readme?.exists).toBe(true);
         expect(readme?.lineCount).toBe(2);
         expect(designs?.exists).toBe(true);
-        expect(designs?.markdownFiles?.[0].path.endsWith("feature-design.md")).toBe(true);
+        expect(designs?.markdownFiles?.[0].path.endsWith('feature-design.md')).toBe(true);
     });
 });

package/output/source/common/index.js

@@ -1,10 +1,11 @@
-export * from "./errors.js";
-export * from "./types.js";
-export * from "./utils.js";
-export * from "./markdown.js";
-export * from "./files.js";
-export * from "./response.js";
-export * from "./catch.js";
-export * from "./artifacts.js";
-export * from "./linter.js";
-export * from "./store.js";
+export * from './errors.js';
+export * from './types.js';
+export * from './utils.js';
+export * from './markdown.js';
+export * from './files.js';
+export * from './response.js';
+export * from './catch.js';
+export * from './artifacts.js';
+export * from './linter.js';
+export * from './store.js';
+export * from './tool.js';

package/output/source/common/linter.js

@@ -1,39 +1,41 @@
 export function renderLintSuggestions(suggestions) {
     return suggestions.map((item) => {
-        const suffix = item.fixHint ? ` ${item.fixHint}` : "";
+        const suffix = item.fixHint ? ` ${item.fixHint}` : '';
         return `- [${item.code}] ${item.message}${suffix}`;
     });
 }
 export const TASK_LINT_CODES = {
-    DUPLICATE_ID: "TASK_DUPLICATE_ID",
-    IN_PROGRESS_OWNER_EMPTY: "TASK_IN_PROGRESS_OWNER_EMPTY",
-    DONE_LINKS_MISSING: "TASK_DONE_LINKS_MISSING",
-    BLOCKED_SUMMARY_EMPTY: "TASK_BLOCKED_SUMMARY_EMPTY",
-    UPDATED_AT_INVALID: "TASK_UPDATED_AT_INVALID",
-    ROADMAP_REFS_EMPTY: "TASK_ROADMAP_REFS_EMPTY",
-    OUTSIDE_MARKER: "TASK_OUTSIDE_MARKER",
-    LINK_TARGET_MISSING: "TASK_LINK_TARGET_MISSING",
-    LINK_PATH_FORMAT_INVALID: "TASK_LINK_PATH_FORMAT_INVALID",
-    HOOK_FILE_MISSING: "TASK_HOOK_FILE_MISSING",
-    FILTER_EMPTY: "TASK_FILTER_EMPTY",
-    CONTEXT_HOOK_HEAD_MISSING: "TASK_CONTEXT_HOOK_HEAD_MISSING",
-    CONTEXT_HOOK_FOOTER_MISSING: "TASK_CONTEXT_HOOK_FOOTER_MISSING",
+    DUPLICATE_ID: 'TASK_DUPLICATE_ID',
+    IN_PROGRESS_OWNER_EMPTY: 'TASK_IN_PROGRESS_OWNER_EMPTY',
+    DONE_LINKS_MISSING: 'TASK_DONE_LINKS_MISSING',
+    BLOCKED_SUMMARY_EMPTY: 'TASK_BLOCKED_SUMMARY_EMPTY',
+    UPDATED_AT_INVALID: 'TASK_UPDATED_AT_INVALID',
+    ROADMAP_REFS_EMPTY: 'TASK_ROADMAP_REFS_EMPTY',
+    OUTSIDE_MARKER: 'TASK_OUTSIDE_MARKER',
+    LINK_PATH_FORMAT_INVALID: 'TASK_LINK_PATH_FORMAT_INVALID',
+    HOOK_FILE_MISSING: 'TASK_HOOK_FILE_MISSING',
+    FILTER_EMPTY: 'TASK_FILTER_EMPTY',
+    CONTEXT_HOOK_HEAD_MISSING: 'TASK_CONTEXT_HOOK_HEAD_MISSING',
+    CONTEXT_HOOK_FOOTER_MISSING: 'TASK_CONTEXT_HOOK_FOOTER_MISSING',
     // Spec v1.1.0 - Blocker Categorization
-    BLOCKED_WITHOUT_BLOCKER: "TASK_BLOCKED_WITHOUT_BLOCKER",
-    BLOCKER_TYPE_INVALID: "TASK_BLOCKER_TYPE_INVALID",
-    BLOCKER_DESCRIPTION_EMPTY: "TASK_BLOCKER_DESCRIPTION_EMPTY",
-    IN_PROGRESS_WITHOUT_SUBSTATE: "TASK_IN_PROGRESS_WITHOUT_SUBSTATE",
-    SUBSTATE_PHASE_INVALID: "TASK_SUBSTATE_PHASE_INVALID",
-    SUBSTATE_CONFIDENCE_INVALID: "TASK_SUBSTATE_CONFIDENCE_INVALID",
+    BLOCKED_WITHOUT_BLOCKER: 'TASK_BLOCKED_WITHOUT_BLOCKER',
+    BLOCKER_TYPE_INVALID: 'TASK_BLOCKER_TYPE_INVALID',
+    BLOCKER_DESCRIPTION_EMPTY: 'TASK_BLOCKER_DESCRIPTION_EMPTY',
+    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',
 };
 export const ROADMAP_LINT_CODES = {
-    IDS_EMPTY: "ROADMAP_IDS_EMPTY",
-    TASKS_EMPTY: "ROADMAP_TASKS_EMPTY",
-    TASK_REFS_EMPTY: "ROADMAP_TASK_REFS_EMPTY",
-    UNKNOWN_REFS: "ROADMAP_UNKNOWN_REFS",
-    ZERO_LINKED_TASKS: "ROADMAP_ZERO_LINKED_TASKS",
-    CONTEXT_RELATED_TASKS_EMPTY: "ROADMAP_CONTEXT_RELATED_TASKS_EMPTY",
+    IDS_EMPTY: 'ROADMAP_IDS_EMPTY',
+    TASKS_EMPTY: 'ROADMAP_TASKS_EMPTY',
+    TASK_REFS_EMPTY: 'ROADMAP_TASK_REFS_EMPTY',
+    UNKNOWN_REFS: 'ROADMAP_UNKNOWN_REFS',
+    ZERO_LINKED_TASKS: 'ROADMAP_ZERO_LINKED_TASKS',
+    CONTEXT_RELATED_TASKS_EMPTY: 'ROADMAP_CONTEXT_RELATED_TASKS_EMPTY',
 };
 export const PROJECT_LINT_CODES = {
-    TASKS_FILE_MISSING: "PROJECT_TASKS_FILE_MISSING",
+    TASKS_FILE_MISSING: 'PROJECT_TASKS_FILE_MISSING',
+    ARCHITECTURE_DOC_MISSING: 'PROJECT_ARCHITECTURE_DOC_MISSING',
+    STYLE_DOC_MISSING: 'PROJECT_STYLE_DOC_MISSING',
 };

package/output/source/common/linter.test.js

@@ -1,16 +1,16 @@
-import { describe, expect, it } from "vitest";
-import { renderLintSuggestions } from "./linter.js";
-describe("renderLintSuggestions", () => {
-    it("renders lint lines with code and message", () => {
+import { describe, expect, it } from 'vitest';
+import { renderLintSuggestions } from './linter.js';
+describe('renderLintSuggestions', () => {
+    it('renders lint lines with code and message', () => {
         const lines = renderLintSuggestions([
-            { code: "TASK_001", message: "Example lint" },
+            { code: 'TASK_001', message: 'Example lint' },
         ]);
-        expect(lines).toEqual(["- [TASK_001] Example lint"]);
+        expect(lines).toEqual(['- [TASK_001] Example lint']);
     });
-    it("appends fixHint when provided", () => {
+    it('appends fixHint when provided', () => {
         const lines = renderLintSuggestions([
-            { code: "TASK_002", message: "Missing field.", fixHint: "Set owner." },
+            { code: 'TASK_002', message: 'Missing field.', fixHint: 'Set owner.' },
         ]);
-        expect(lines).toEqual(["- [TASK_002] Missing field. Set owner."]);
+        expect(lines).toEqual(['- [TASK_002] Missing field. Set owner.']);
     });
 });

package/output/source/common/markdown.js

@@ -1,6 +1,6 @@
-import fs from "node:fs/promises";
+import fs from 'node:fs/promises';
 export async function readMarkdownSections(filePath) {
-    const content = await fs.readFile(filePath, "utf-8");
+    const content = await fs.readFile(filePath, 'utf-8');
     const lines = content.split(/\r?\n/);
     const headers = [];
     lines.forEach((line, index) => {
@@ -21,7 +21,7 @@ export async function readMarkdownSections(filePath) {
     return { filePath, lineCount: lines.length, sections };
 }
 export async function findTextReferences(filePath, needle) {
-    const content = await fs.readFile(filePath, "utf-8");
+    const content = await fs.readFile(filePath, 'utf-8');
     const lines = content.split(/\r?\n/);
     const result = [];
     lines.forEach((line, index) => {

package/output/source/common/markdown.test.js

@@ -1,11 +1,11 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
 import { findTextReferences, readMarkdownSections } from './markdown.js';
 const tempPaths = [];
 async function createTempDir() {
-    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "projitive-mcp-test-"));
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'projitive-mcp-test-'));
     tempPaths.push(dir);
     return dir;
 }
@@ -14,22 +14,22 @@ afterEach(async () => {
         await fs.rm(dir, { recursive: true, force: true });
     }));
 });
-describe("markdown module", () => {
-    it("locates markdown sections with line ranges", async () => {
+describe('markdown module', () => {
+    it('locates markdown sections with line ranges', async () => {
         const root = await createTempDir();
-        const file = path.join(root, "tasks.md");
-        await fs.writeFile(file, ["# Tasks", "", "## TODO", "- TASK-0001", "## DONE", "- TASK-0002"].join("\n"), "utf-8");
+        const file = path.join(root, 'tasks.md');
+        await fs.writeFile(file, ['# Tasks', '', '## TODO', '- TASK-0001', '## DONE', '- TASK-0002'].join('\n'), 'utf-8');
         const located = await readMarkdownSections(file);
         expect(located.lineCount).toBe(6);
-        expect(located.sections[0].heading).toBe("Tasks");
-        expect(located.sections[1].heading).toBe("TODO");
+        expect(located.sections[0].heading).toBe('Tasks');
+        expect(located.sections[1].heading).toBe('TODO');
         expect(located.sections[1].startLine).toBe(3);
     });
-    it("finds ID references with exact line number", async () => {
+    it('finds ID references with exact line number', async () => {
         const root = await createTempDir();
-        const file = path.join(root, "reports.md");
-        await fs.writeFile(file, ["Task: TASK-0001", "Roadmap: ROADMAP-0001"].join("\n"), "utf-8");
-        const refs = await findTextReferences(file, "TASK-0001");
+        const file = path.join(root, 'reports.md');
+        await fs.writeFile(file, ['Task: TASK-0001', 'Roadmap: ROADMAP-0001'].join('\n'), 'utf-8');
+        const refs = await findTextReferences(file, 'TASK-0001');
         expect(refs).toHaveLength(1);
         expect(refs[0].line).toBe(1);
     });