@projitive/mcp 1.0.7 → 1.1.1

package/output/source/common/errors.js

@@ -0,0 +1,120 @@
+// Projitive unified error type definitions
+export class ProjitiveError extends Error {
+    code;
+    details;
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "ProjitiveError";
+    }
+}
+// Project related errors
+export class ProjectError extends ProjitiveError {
+    constructor(message, code, details) {
+        super(message, code, details);
+        this.name = "ProjectError";
+    }
+}
+export class ProjectNotFoundError extends ProjectError {
+    constructor(inputPath) {
+        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 });
+    }
+}
+// Task related errors
+export class TaskError extends ProjitiveError {
+    constructor(message, code, details) {
+        super(message, code, details);
+        this.name = "TaskError";
+    }
+}
+export class TaskNotFoundError extends TaskError {
+    constructor(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 });
+    }
+}
+export class TaskValidationError extends TaskError {
+    errors;
+    constructor(taskId, errors) {
+        super(`Task validation failed for ${taskId}: ${errors.join(", ")}`, "TASK_VALIDATION_FAILED", { taskId, errors });
+        this.errors = errors;
+    }
+}
+// File operation errors
+export class FileError extends ProjitiveError {
+    filePath;
+    constructor(message, filePath, code, details) {
+        super(message, code || "FILE_ERROR", { filePath, ...details });
+        this.filePath = filePath;
+        this.name = "FileError";
+    }
+}
+export class FileNotFoundError extends FileError {
+    constructor(filePath) {
+        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", {
+            cause: cause?.message,
+        });
+    }
+}
+export class FileWriteError extends FileError {
+    constructor(filePath, cause) {
+        super(`Failed to write file: ${filePath}`, filePath, "FILE_WRITE_ERROR", {
+            cause: cause?.message,
+        });
+    }
+}
+// Validation errors
+export class ValidationError extends ProjitiveError {
+    errors;
+    constructor(message, errors = [], code) {
+        super(message, code || "VALIDATION_FAILED", { errors });
+        this.errors = errors;
+        this.name = "ValidationError";
+    }
+}
+export class ConfidenceScoreError extends ValidationError {
+    score;
+    constructor(message, score, errors = []) {
+        super(message, errors, "CONFIDENCE_SCORE_ERROR");
+        this.score = score;
+        this.score = score;
+    }
+}
+// MCP related errors
+export class MCPError extends ProjitiveError {
+    constructor(message, code, details) {
+        super(message, code, details);
+        this.name = "MCPError";
+    }
+}
+export class ResourceNotFoundError extends MCPError {
+    constructor(resourceUri) {
+        super(`Resource not found: ${resourceUri}`, "RESOURCE_NOT_FOUND", {
+            resourceUri,
+        });
+    }
+}
+export class PromptNotFoundError extends MCPError {
+    constructor(promptName) {
+        super(`Prompt not found: ${promptName}`, "PROMPT_NOT_FOUND", {
+            promptName,
+        });
+    }
+}

package/output/source/{helpers/files → common}/files.js

@@ -1,6 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { catchIt } from "../catch/index.js";
+import { catchIt } from "./catch.js";
 const FILE_ARTIFACTS = ["README.md", "roadmap.md", "tasks.md"];
 const DIRECTORY_ARTIFACTS = ["designs", "reports", "hooks"];
 async function fileLineCount(filePath) {

package/output/source/{helpers/files → common}/files.test.js

@@ -2,7 +2,7 @@ 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";
+import { discoverGovernanceArtifacts } from './files.js';
 const tempPaths = [];
 async function createTempDir() {
     const dir = await fs.mkdtemp(path.join(os.tmpdir(), "projitive-mcp-test-"));

package/output/source/common/index.js

@@ -0,0 +1,10 @@
+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 "./confidence.js";
+export * from "./catch.js";
+export * from "./artifacts.js";
+export * from "./linter.js";

package/output/source/{helpers/linter/codes.js → common/linter.js}

@@ -1,3 +1,9 @@
+export function renderLintSuggestions(suggestions) {
+    return suggestions.map((item) => {
+        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",
@@ -11,6 +17,13 @@ export const TASK_LINT_CODES = {
     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",
 };
 export const ROADMAP_LINT_CODES = {
     IDS_EMPTY: "ROADMAP_IDS_EMPTY",

package/output/source/{helpers/markdown → common}/markdown.test.js

@@ -2,7 +2,7 @@ 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";
+import { findTextReferences, readMarkdownSections } from './markdown.js';
 const tempPaths = [];
 async function createTempDir() {
     const dir = await fs.mkdtemp(path.join(os.tmpdir(), "projitive-mcp-test-"));

package/output/source/{helpers/response → common}/response.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { asText, nextCallSection, renderErrorMarkdown, renderToolResponseMarkdown, summarySection, } from "./response.js";
+import { asText, nextCallSection, renderErrorMarkdown, renderToolResponseMarkdown, summarySection, } from './response.js';
 describe("response helpers", () => {
     it("wraps markdown text as MCP text content", () => {
         const result = asText("# hello");

package/output/source/common/types.js

@@ -0,0 +1,7 @@
+// Common type definitions (simplified)
+export const VALID_STATUS_TRANSITIONS = {
+    TODO: ["IN_PROGRESS"],
+    IN_PROGRESS: ["TODO", "BLOCKED", "DONE"],
+    BLOCKED: ["IN_PROGRESS"],
+    DONE: [],
+};

package/output/source/common/utils.js

@@ -0,0 +1,39 @@
+// Common utility functions
+import fs from "node:fs/promises";
+import path from "node:path";
+/**
+ * Safely read Markdown file content, return fallback if file doesn't exist or is empty
+ */
+export async function readMarkdownOrFallback(relativePath, fallbackTitle, repoRoot = process.cwd()) {
+    const absolutePath = path.resolve(repoRoot, relativePath);
+    try {
+        const content = await fs.readFile(absolutePath, "utf-8");
+        if (content.trim().length > 0) {
+            return content;
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            console.error(`Failed to read file: ${absolutePath}`, error);
+        }
+    }
+    return [
+        `# ${fallbackTitle}`,
+        "",
+        `- file: ${relativePath}`,
+        "- status: missing-or-empty",
+        "- next: create this file or ensure it has readable markdown content",
+    ].join("\n");
+}
+/**
+ * Capitalize first letter
+ */
+export function capitalizeFirstLetter(str) {
+    return str.split(/[-_]/).map(part => part.charAt(0).toUpperCase() + part.slice(1)).join('');
+}
+/**
+ * Format title
+ */
+export function formatTitle(str) {
+    return str.split(/[-_]/).map(part => part.charAt(0).toUpperCase() + part.slice(1)).join(' ');
+}