@projitive/mcp 2.0.3 → 2.0.4

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

@@ -1,26 +1,26 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { ensureStore, getMarkdownViewState, getStoreVersion, loadActionableTasksFromStore, loadRoadmapIdsFromStore, loadRoadmapsFromStore, loadTaskStatusStatsFromStore, loadTasksFromStore, markMarkdownViewBuilt, markMarkdownViewDirty, replaceRoadmapsInStore, replaceTasksInStore, upsertRoadmapInStore, upsertTaskInStore, } from "./store.js";
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { ensureStore, getMarkdownViewState, getStoreVersion, loadActionableTasksFromStore, loadRoadmapIdsFromStore, loadRoadmapsFromStore, loadTaskStatusStatsFromStore, loadTasksFromStore, markMarkdownViewBuilt, markMarkdownViewDirty, replaceRoadmapsInStore, replaceTasksInStore, upsertRoadmapInStore, upsertTaskInStore, } from './store.js';
 const tempPaths = [];
 async function createTempDbPath() {
-    const sandboxRoot = path.join(process.cwd(), ".tmp", "store-tests");
+    const sandboxRoot = path.join(process.cwd(), '.tmp', 'store-tests');
     await fs.mkdir(sandboxRoot, { recursive: true });
-    const dir = await fs.mkdtemp(path.join(sandboxRoot, "case-"));
+    const dir = await fs.mkdtemp(path.join(sandboxRoot, 'case-'));
     tempPaths.push(dir);
-    return path.join(dir, ".projitive");
+    return path.join(dir, '.projitive');
 }
 async function readRawStore(dbPath) {
-    const content = await fs.readFile(dbPath, "utf8");
+    const content = await fs.readFile(dbPath, 'utf8');
     return JSON.parse(content);
 }
 function task(input) {
     return {
         id: input.id,
         title: input.title,
-        status: input.status ?? "TODO",
-        owner: input.owner ?? "",
-        summary: input.summary ?? "",
+        status: input.status ?? 'TODO',
+        owner: input.owner ?? '',
+        summary: input.summary ?? '',
         updatedAt: input.updatedAt ?? new Date().toISOString(),
         links: input.links ?? [],
         roadmapRefs: input.roadmapRefs ?? [],
@@ -32,7 +32,7 @@ function milestone(input) {
     return {
         id: input.id,
         title: input.title,
-        status: input.status ?? "active",
+        status: input.status ?? 'active',
         time: input.time,
         updatedAt: input.updatedAt ?? new Date().toISOString(),
     };
@@ -40,12 +40,12 @@ function milestone(input) {
 afterEach(async () => {
     await Promise.all(tempPaths.splice(0).map((dir) => fs.rm(dir, { recursive: true, force: true })));
 });
-describe("store", () => {
-    it("initializes JSON store with default meta/view state", async () => {
+describe('store', () => {
+    it('initializes JSON store with default meta/view state', async () => {
         const dbPath = await createTempDbPath();
         await ensureStore(dbPath);
         const store = await readRawStore(dbPath);
-        expect(store.schema).toBe("projitive-json-store");
+        expect(store.schema).toBe('projitive-json-store');
         expect(store.meta.store_schema_version).toBe(3);
         expect(store.meta.tasks_version).toBe(0);
         expect(store.meta.roadmaps_version).toBe(0);
@@ -55,65 +55,65 @@ describe("store", () => {
         expect(store.view_state.roadmaps_markdown.lastSourceVersion).toBe(0);
         expect(Array.isArray(store.migration_history)).toBe(true);
     });
-    it("tracks view state dirty/build transitions", async () => {
+    it('tracks view state dirty/build transitions', async () => {
         const dbPath = await createTempDbPath();
         await ensureStore(dbPath);
-        const initial = await getMarkdownViewState(dbPath, "tasks_markdown");
+        const initial = await getMarkdownViewState(dbPath, 'tasks_markdown');
         expect(initial.dirty).toBe(true);
-        await markMarkdownViewBuilt(dbPath, "tasks_markdown", 7, "2026-03-13T00:00:00.000Z");
-        const built = await getMarkdownViewState(dbPath, "tasks_markdown");
+        await markMarkdownViewBuilt(dbPath, 'tasks_markdown', 7, '2026-03-13T00:00:00.000Z');
+        const built = await getMarkdownViewState(dbPath, 'tasks_markdown');
         expect(built.dirty).toBe(false);
         expect(built.lastSourceVersion).toBe(7);
-        expect(built.lastBuiltAt).toBe("2026-03-13T00:00:00.000Z");
-        await markMarkdownViewDirty(dbPath, "tasks_markdown");
-        const dirtyAgain = await getMarkdownViewState(dbPath, "tasks_markdown");
+        expect(built.lastBuiltAt).toBe('2026-03-13T00:00:00.000Z');
+        await markMarkdownViewDirty(dbPath, 'tasks_markdown');
+        const dirtyAgain = await getMarkdownViewState(dbPath, 'tasks_markdown');
         expect(dirtyAgain.dirty).toBe(true);
         expect(dirtyAgain.lastSourceVersion).toBe(7);
     });
-    it("upserts tasks and updates source/view versions", async () => {
+    it('upserts tasks and updates source/view versions', async () => {
         const dbPath = await createTempDbPath();
         await ensureStore(dbPath);
         await upsertTaskInStore(dbPath, task({
-            id: "TASK-0001",
-            title: "First",
-            status: "TODO",
-            owner: "alice",
-            summary: "first",
-            updatedAt: "2026-03-13T00:00:00.000Z",
-            roadmapRefs: ["ROADMAP-0001"],
+            id: 'TASK-0001',
+            title: 'First',
+            status: 'TODO',
+            owner: 'alice',
+            summary: 'first',
+            updatedAt: '2026-03-13T00:00:00.000Z',
+            roadmapRefs: ['ROADMAP-0001'],
         }));
         await upsertTaskInStore(dbPath, task({
-            id: "TASK-0001",
-            title: "First Updated",
-            status: "IN_PROGRESS",
-            owner: "alice",
-            summary: "updated",
-            updatedAt: "2026-03-13T01:00:00.000Z",
-            roadmapRefs: ["ROADMAP-0001"],
-            links: ["reports/r1.md"],
+            id: 'TASK-0001',
+            title: 'First Updated',
+            status: 'IN_PROGRESS',
+            owner: 'alice',
+            summary: 'updated',
+            updatedAt: '2026-03-13T01:00:00.000Z',
+            roadmapRefs: ['ROADMAP-0001'],
+            links: ['reports/r1.md'],
         }));
         const tasks = await loadTasksFromStore(dbPath);
         expect(tasks).toHaveLength(1);
-        expect(tasks[0].title).toBe("First Updated");
-        expect(tasks[0].status).toBe("IN_PROGRESS");
-        expect(tasks[0].links).toEqual(["reports/r1.md"]);
-        const tasksVersion = await getStoreVersion(dbPath, "tasks");
+        expect(tasks[0].title).toBe('First Updated');
+        expect(tasks[0].status).toBe('IN_PROGRESS');
+        expect(tasks[0].links).toEqual(['reports/r1.md']);
+        const tasksVersion = await getStoreVersion(dbPath, 'tasks');
         expect(tasksVersion).toBe(2);
-        const viewState = await getMarkdownViewState(dbPath, "tasks_markdown");
+        const viewState = await getMarkdownViewState(dbPath, 'tasks_markdown');
         expect(viewState.dirty).toBe(true);
         const store = await readRawStore(dbPath);
-        const updated = store.tasks.find((item) => item.id === "TASK-0001");
+        const updated = store.tasks.find((item) => item.id === 'TASK-0001');
         expect(updated?.recordVersion).toBe(2);
     });
-    it("replaces task set and computes actionable ranking/stats", async () => {
+    it('replaces task set and computes actionable ranking/stats', async () => {
         const dbPath = await createTempDbPath();
         await ensureStore(dbPath);
         await replaceTasksInStore(dbPath, [
-            task({ id: "TASK-0001", title: "Todo older", status: "TODO", updatedAt: "2026-03-10T00:00:00.000Z" }),
-            task({ id: "TASK-0002", title: "In progress", status: "IN_PROGRESS", updatedAt: "2026-03-12T00:00:00.000Z" }),
-            task({ id: "TASK-0003", title: "Todo newer", status: "TODO", updatedAt: "2026-03-13T00:00:00.000Z" }),
-            task({ id: "TASK-0004", title: "Blocked", status: "BLOCKED", updatedAt: "2026-03-11T00:00:00.000Z" }),
-            task({ id: "TASK-0005", title: "Done", status: "DONE", updatedAt: "2026-03-09T00:00:00.000Z" }),
+            task({ id: 'TASK-0001', title: 'Todo older', status: 'TODO', updatedAt: '2026-03-10T00:00:00.000Z' }),
+            task({ id: 'TASK-0002', title: 'In progress', status: 'IN_PROGRESS', updatedAt: '2026-03-12T00:00:00.000Z' }),
+            task({ id: 'TASK-0003', title: 'Todo newer', status: 'TODO', updatedAt: '2026-03-13T00:00:00.000Z' }),
+            task({ id: 'TASK-0004', title: 'Blocked', status: 'BLOCKED', updatedAt: '2026-03-11T00:00:00.000Z' }),
+            task({ id: 'TASK-0005', title: 'Done', status: 'DONE', updatedAt: '2026-03-09T00:00:00.000Z' }),
         ]);
         const stats = await loadTaskStatusStatsFromStore(dbPath);
         expect(stats.todo).toBe(2);
@@ -121,44 +121,44 @@ describe("store", () => {
         expect(stats.blocked).toBe(1);
         expect(stats.done).toBe(1);
         expect(stats.total).toBe(5);
-        expect(stats.latestUpdatedAt).toBe("2026-03-13T00:00:00.000Z");
+        expect(stats.latestUpdatedAt).toBe('2026-03-13T00:00:00.000Z');
         const actionable = await loadActionableTasksFromStore(dbPath, 2);
         expect(actionable).toHaveLength(2);
-        expect(actionable[0].id).toBe("TASK-0002");
-        expect(actionable[1].id).toBe("TASK-0003");
-        const tasksVersion = await getStoreVersion(dbPath, "tasks");
+        expect(actionable[0].id).toBe('TASK-0002');
+        expect(actionable[1].id).toBe('TASK-0003');
+        const tasksVersion = await getStoreVersion(dbPath, 'tasks');
         expect(tasksVersion).toBe(1);
     });
-    it("upserts/replaces roadmaps and updates versions", async () => {
+    it('upserts/replaces roadmaps and updates versions', async () => {
         const dbPath = await createTempDbPath();
         await ensureStore(dbPath);
         await upsertRoadmapInStore(dbPath, milestone({
-            id: "ROADMAP-0001",
-            title: "Phase 1",
-            status: "active",
-            updatedAt: "2026-03-10T00:00:00.000Z",
+            id: 'ROADMAP-0001',
+            title: 'Phase 1',
+            status: 'active',
+            updatedAt: '2026-03-10T00:00:00.000Z',
         }));
         await upsertRoadmapInStore(dbPath, milestone({
-            id: "ROADMAP-0001",
-            title: "Phase 1 done",
-            status: "done",
-            time: "2026-Q1",
-            updatedAt: "2026-03-11T00:00:00.000Z",
+            id: 'ROADMAP-0001',
+            title: 'Phase 1 done',
+            status: 'done',
+            time: '2026-Q1',
+            updatedAt: '2026-03-11T00:00:00.000Z',
         }));
         const list1 = await loadRoadmapsFromStore(dbPath);
         expect(list1).toHaveLength(1);
-        expect(list1[0].title).toBe("Phase 1 done");
-        expect(list1[0].status).toBe("done");
-        expect(list1[0].time).toBe("2026-Q1");
+        expect(list1[0].title).toBe('Phase 1 done');
+        expect(list1[0].status).toBe('done');
+        expect(list1[0].time).toBe('2026-Q1');
         await replaceRoadmapsInStore(dbPath, [
-            milestone({ id: "ROADMAP-0002", title: "Phase 2", status: "active", updatedAt: "2026-03-12T00:00:00.000Z" }),
-            milestone({ id: "ROADMAP-0003", title: "Phase 3", status: "done", updatedAt: "2026-03-13T00:00:00.000Z" }),
+            milestone({ id: 'ROADMAP-0002', title: 'Phase 2', status: 'active', updatedAt: '2026-03-12T00:00:00.000Z' }),
+            milestone({ id: 'ROADMAP-0003', title: 'Phase 3', status: 'done', updatedAt: '2026-03-13T00:00:00.000Z' }),
         ]);
         const ids = await loadRoadmapIdsFromStore(dbPath);
-        expect(ids).toEqual(["ROADMAP-0003", "ROADMAP-0002"]);
-        const roadmapsVersion = await getStoreVersion(dbPath, "roadmaps");
+        expect(ids).toEqual(['ROADMAP-0003', 'ROADMAP-0002']);
+        const roadmapsVersion = await getStoreVersion(dbPath, 'roadmaps');
         expect(roadmapsVersion).toBe(3);
-        const viewState = await getMarkdownViewState(dbPath, "roadmaps_markdown");
+        const viewState = await getMarkdownViewState(dbPath, 'roadmaps_markdown');
         expect(viewState.dirty).toBe(true);
     });
 });

package/output/source/common/types.js

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

package/output/source/common/utils.js

@@ -1,29 +1,29 @@
 // Common utility functions
-import fs from "node:fs/promises";
-import path from "node:path";
+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");
+        const content = await fs.readFile(absolutePath, 'utf-8');
         if (content.trim().length > 0) {
             return content;
         }
     }
     catch (error) {
-        if (error.code !== "ENOENT") {
+        if (!(error && typeof error === 'object' && 'code' in error && 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");
+        '- status: missing-or-empty',
+        '- next: create this file or ensure it has readable markdown content',
+    ].join('\n');
 }
 /**
  * Capitalize first letter

package/output/source/index.js

@@ -1,36 +1,36 @@
 #!/usr/bin/env node
-import path from "node:path";
-import process from "node:process";
-import { fileURLToPath } from "node:url";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import packageJson from "../package.json" with { type: "json" };
-import { registerTools } from "./tools/index.js";
-import { registerPrompts } from "./prompts/index.js";
-import { registerResources } from "./resources/index.js";
-const PROJITIVE_SPEC_VERSION = "1.1.0";
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import packageJson from '../package.json' with { type: 'json' };
+import { registerTools } from './tools/index.js';
+import { registerPrompts } from './prompts/index.js';
+import { registerResources } from './resources/index.js';
+const PROJITIVE_SPEC_VERSION = '1.1.0';
 const currentFilePath = fileURLToPath(import.meta.url);
 const sourceDir = path.dirname(currentFilePath);
-const repoRoot = path.resolve(sourceDir, "..", "..", "..");
-const MCP_RUNTIME_VERSION = typeof packageJson.version === "string" && packageJson.version.trim().length > 0
+const repoRoot = path.resolve(sourceDir, '..', '..', '..');
+const MCP_RUNTIME_VERSION = typeof packageJson.version === 'string' && packageJson.version.trim().length > 0
     ? packageJson.version.trim()
     : PROJITIVE_SPEC_VERSION;
 const server = new McpServer({
-    name: "projitive",
+    name: 'projitive',
     version: MCP_RUNTIME_VERSION,
-    description: "Semantic Projitive MCP for project/task discovery and agent guidance with governance-store-first outputs",
+    description: 'Semantic Projitive MCP for project/task discovery and agent guidance with governance-store-first outputs',
 });
 // 注册所有模块
 registerTools(server);
 registerPrompts(server);
 registerResources(server, repoRoot);
 async function main() {
-    console.error(`[projitive-mcp] starting server`);
+    console.error('[projitive-mcp] starting server');
     console.error(`[projitive-mcp] version=${MCP_RUNTIME_VERSION} spec=${PROJITIVE_SPEC_VERSION} transport=stdio pid=${process.pid}`);
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }
 void main().catch((error) => {
-    console.error("Server error:", error);
+    console.error('Server error:', error);
     process.exit(1);
 });

package/output/source/index.test.js

@@ -1,46 +1,46 @@
-import { describe, it, expect, beforeAll, afterAll, vi, beforeEach } from "vitest";
-import fs from "node:fs/promises";
-import path from "node:path";
-import os from "node:os";
-import { fileURLToPath } from "node:url";
+import { describe, it, expect, beforeAll, afterAll, vi, beforeEach } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
 const currentFilePath = fileURLToPath(import.meta.url);
 const sourceDir = path.dirname(currentFilePath);
 // Mock McpServer and StdioServerTransport
-vi.mock("@modelcontextprotocol/sdk/server/mcp.js", () => ({
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js', () => ({
     McpServer: vi.fn().mockImplementation(() => ({
         registerResource: vi.fn(),
         registerPrompt: vi.fn(),
         connect: vi.fn().mockResolvedValue(undefined),
     })),
 }));
-vi.mock("@modelcontextprotocol/sdk/server/stdio.js", () => ({
+vi.mock('@modelcontextprotocol/sdk/server/stdio.js', () => ({
     StdioServerTransport: vi.fn().mockImplementation(() => ({})),
 }));
 // Mock the registration functions
-vi.mock("./tools/project.js", () => ({
+vi.mock('./tools/project.js', () => ({
     registerProjectTools: vi.fn(),
 }));
-vi.mock("./tools/task.js", () => ({
+vi.mock('./tools/task.js', () => ({
     registerTaskTools: vi.fn(),
 }));
-vi.mock("./tools/roadmap.js", () => ({
+vi.mock('./tools/roadmap.js', () => ({
     registerRoadmapTools: vi.fn(),
 }));
-vi.mock("./resources/governance.js", () => ({
+vi.mock('./resources/governance.js', () => ({
     registerGovernanceResources: vi.fn(),
 }));
-vi.mock("./resources/designs.js", () => ({
+vi.mock('./resources/designs.js', () => ({
     registerDesignFilesResources: vi.fn(),
 }));
-vi.mock("./prompts/governance.js", () => ({
+vi.mock('./prompts/governance.js', () => ({
     registerGovernancePrompts: vi.fn(),
 }));
-describe("index module", () => {
+describe('index module', () => {
     let tempDir;
     let testProjectDir;
     beforeAll(async () => {
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "projitive-index-test-"));
-        testProjectDir = path.join(tempDir, "test-project");
+        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'projitive-index-test-'));
+        testProjectDir = path.join(tempDir, 'test-project');
         await fs.mkdir(testProjectDir);
     });
     afterAll(async () => {
@@ -49,62 +49,62 @@ describe("index module", () => {
     beforeEach(() => {
         vi.clearAllMocks();
     });
-    it("should export the main server entry point", async () => {
-        const indexPath = path.join(sourceDir, "index.ts");
+    it('should export the main server entry point', async () => {
+        const indexPath = path.join(sourceDir, 'index.ts');
         const exists = await fs.access(indexPath).then(() => true).catch(() => false);
         expect(exists).toBe(true);
     });
-    it("should have the correct shebang and imports", async () => {
-        const indexPath = path.join(sourceDir, "index.ts");
-        const content = await fs.readFile(indexPath, "utf-8");
-        expect(content.startsWith("#!/usr/bin/env node")).toBe(true);
-        expect(content).toContain("McpServer");
-        expect(content).toContain("StdioServerTransport");
-        expect(content).toContain("registerTools");
-        expect(content).toContain("registerResources");
-        expect(content).toContain("registerPrompts");
+    it('should have the correct shebang and imports', async () => {
+        const indexPath = path.join(sourceDir, 'index.ts');
+        const content = await fs.readFile(indexPath, 'utf-8');
+        expect(content.startsWith('#!/usr/bin/env node')).toBe(true);
+        expect(content).toContain('McpServer');
+        expect(content).toContain('StdioServerTransport');
+        expect(content).toContain('registerTools');
+        expect(content).toContain('registerResources');
+        expect(content).toContain('registerPrompts');
     });
-    it("should define PROJITIVE_SPEC_VERSION as 1.1.0", async () => {
-        const indexPath = path.join(sourceDir, "index.ts");
-        const content = await fs.readFile(indexPath, "utf-8");
-        expect(content).toContain("PROJITIVE_SPEC_VERSION");
-        expect(content).toContain('"1.1.0"');
+    it('should define PROJITIVE_SPEC_VERSION as 1.1.0', async () => {
+        const indexPath = path.join(sourceDir, 'index.ts');
+        const content = await fs.readFile(indexPath, 'utf-8');
+        expect(content).toContain('PROJITIVE_SPEC_VERSION');
+        expect(content).toContain("'1.1.0'");
     });
-    it("should have main function with server startup", async () => {
-        const indexPath = path.join(sourceDir, "index.ts");
-        const content = await fs.readFile(indexPath, "utf-8");
-        expect(content).toContain("async function main");
-        expect(content).toContain("server.connect");
-        expect(content).toContain("StdioServerTransport");
+    it('should have main function with server startup', async () => {
+        const indexPath = path.join(sourceDir, 'index.ts');
+        const content = await fs.readFile(indexPath, 'utf-8');
+        expect(content).toContain('async function main');
+        expect(content).toContain('server.connect');
+        expect(content).toContain('StdioServerTransport');
     });
-    it("should register all tool categories", async () => {
-        const indexPath = path.join(sourceDir, "index.ts");
-        const content = await fs.readFile(indexPath, "utf-8");
-        expect(content).toContain("registerTools(server)");
-        expect(content).toContain("registerResources(server, repoRoot)");
-        expect(content).toContain("registerPrompts(server)");
+    it('should register all tool categories', async () => {
+        const indexPath = path.join(sourceDir, 'index.ts');
+        const content = await fs.readFile(indexPath, 'utf-8');
+        expect(content).toContain('registerTools(server)');
+        expect(content).toContain('registerResources(server, repoRoot)');
+        expect(content).toContain('registerPrompts(server)');
     });
-    it("should have proper error handling in main", async () => {
-        const indexPath = path.join(sourceDir, "index.ts");
-        const content = await fs.readFile(indexPath, "utf-8");
-        expect(content).toContain("void main().catch");
-        expect(content).toContain("console.error(\"Server error:\", error)");
-        expect(content).toContain("process.exit(1)");
+    it('should have proper error handling in main', async () => {
+        const indexPath = path.join(sourceDir, 'index.ts');
+        const content = await fs.readFile(indexPath, 'utf-8');
+        expect(content).toContain('void main().catch');
+        expect(content).toContain("console.error('Server error:', error)");
+        expect(content).toContain('process.exit(1)');
     });
-    it("should log server startup information", async () => {
-        const indexPath = path.join(sourceDir, "index.ts");
-        const content = await fs.readFile(indexPath, "utf-8");
-        expect(content).toContain("console.error(`[projitive-mcp] starting server`)");
-        expect(content).toContain("console.error(`[projitive-mcp] version=");
-        expect(content).toContain("spec=");
-        expect(content).toContain("transport=stdio");
-        expect(content).toContain("pid=");
+    it('should log server startup information', async () => {
+        const indexPath = path.join(sourceDir, 'index.ts');
+        const content = await fs.readFile(indexPath, 'utf-8');
+        expect(content).toContain("console.error('[projitive-mcp] starting server')");
+        expect(content).toContain('console.error(`[projitive-mcp] version=');
+        expect(content).toContain('spec=');
+        expect(content).toContain('transport=stdio');
+        expect(content).toContain('pid=');
     });
-    it("should define MCP server with correct metadata", async () => {
-        const indexPath = path.join(sourceDir, "index.ts");
-        const content = await fs.readFile(indexPath, "utf-8");
-        expect(content).toContain("name: \"projitive\"");
-        expect(content).toContain("version: MCP_RUNTIME_VERSION");
-        expect(content).toContain("description:");
+    it('should define MCP server with correct metadata', async () => {
+        const indexPath = path.join(sourceDir, 'index.ts');
+        const content = await fs.readFile(indexPath, 'utf-8');
+        expect(content).toContain("name: 'projitive'");
+        expect(content).toContain('version: MCP_RUNTIME_VERSION');
+        expect(content).toContain('description:');
     });
 });

package/output/source/prompts/index.js

@@ -1,7 +1,7 @@
 // Governance workflow prompts
-import { registerQuickStartPrompt } from "./quickStart.js";
-import { registerTaskDiscoveryPrompt } from "./taskDiscovery.js";
-import { registerTaskExecutionPrompt } from "./taskExecution.js";
+import { registerQuickStartPrompt } from './quickStart.js';
+import { registerTaskDiscoveryPrompt } from './taskDiscovery.js';
+import { registerTaskExecutionPrompt } from './taskExecution.js';
 export function registerPrompts(server) {
     registerQuickStartPrompt(server);
     registerTaskDiscoveryPrompt(server);