@sureshdsk/devflow-mcp 3.0.0 → 3.0.2

package/scripts/init-schema.test.js

@@ -1,18 +1,18 @@
-const test = require("node:test");
-const assert = require("node:assert/strict");
-const fs = require("fs");
-const os = require("os");
-const path = require("path");
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 
 const {
   discoverSchemaTemplates,
   resolveInitSchemaSelection,
   readProjectConfig,
   writeProjectConfig,
-} = require("./init-schema");
+} = require('./init-schema');
 
 function withTempDir(fn) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "devflow-init-schema-"));
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'devflow-init-schema-'));
   try {
     return fn(dir);
   } finally {
@@ -22,82 +22,82 @@ function withTempDir(fn) {
 
 function writeSchema(baseDir, id) {
   const schemaDir = path.join(baseDir, id);
-  fs.mkdirSync(path.join(schemaDir, "templates"), { recursive: true });
+  fs.mkdirSync(path.join(schemaDir, 'templates'), { recursive: true });
   fs.writeFileSync(
-    path.join(schemaDir, "schema.yaml"),
+    path.join(schemaDir, 'schema.yaml'),
     `name: ${id}\nversion: 1\nartifacts: []\n`,
-    "utf-8"
+    'utf-8',
   );
 }
 
-test("resolveInitSchemaSelection respects explicit schema", async () => {
+test('resolveInitSchemaSelection respects explicit schema', async () => {
   const result = await resolveInitSchemaSelection({
-    requestedSchema: "backend-api",
-    existingDefaultSchema: "spec-driven",
-    availableSchemaIds: ["spec-driven", "backend-api"],
+    requestedSchema: 'backend-api',
+    existingDefaultSchema: 'spec-driven',
+    availableSchemaIds: ['spec-driven', 'backend-api'],
     interactive: false,
   });
-  assert.equal(result.schemaId, "backend-api");
-  assert.equal(result.reason, "explicit");
+  assert.equal(result.schemaId, 'backend-api');
+  assert.equal(result.reason, 'explicit');
 });
 
-test("resolveInitSchemaSelection keeps existing default in interactive mode", async () => {
+test('resolveInitSchemaSelection keeps existing default in interactive mode', async () => {
   const result = await resolveInitSchemaSelection({
-    existingDefaultSchema: "frontend-product",
-    availableSchemaIds: ["frontend-product", "spec-driven"],
+    existingDefaultSchema: 'frontend-product',
+    availableSchemaIds: ['frontend-product', 'spec-driven'],
     interactive: true,
     confirmKeepExisting: async () => true,
-    promptSelectSchema: async () => "spec-driven",
+    promptSelectSchema: async () => 'spec-driven',
   });
-  assert.equal(result.schemaId, "frontend-product");
-  assert.equal(result.reason, "existing-default-kept");
+  assert.equal(result.schemaId, 'frontend-product');
+  assert.equal(result.reason, 'existing-default-kept');
 });
 
-test("resolveInitSchemaSelection uses fallback in non-interactive mode", async () => {
+test('resolveInitSchemaSelection uses fallback in non-interactive mode', async () => {
   const result = await resolveInitSchemaSelection({
-    availableSchemaIds: ["spec-driven", "backend-api"],
+    availableSchemaIds: ['spec-driven', 'backend-api'],
     interactive: false,
   });
-  assert.equal(result.schemaId, "spec-driven");
-  assert.equal(result.reason, "non-interactive-fallback");
+  assert.equal(result.schemaId, 'spec-driven');
+  assert.equal(result.reason, 'non-interactive-fallback');
 });
 
-test("discoverSchemaTemplates returns bundled and project schemas", () =>
+test('discoverSchemaTemplates returns bundled and project schemas', () =>
   withTempDir((root) => {
-    const projectRoot = path.join(root, "project");
-    const packageRoot = path.join(root, "package");
-    const bundledDir = path.join(packageRoot, "src", "schemas");
-    fs.mkdirSync(path.join(projectRoot, "schemas"), { recursive: true });
+    const projectRoot = path.join(root, 'project');
+    const packageRoot = path.join(root, 'package');
+    const bundledDir = path.join(packageRoot, 'src', 'schemas');
+    fs.mkdirSync(path.join(projectRoot, 'schemas'), { recursive: true });
     fs.mkdirSync(bundledDir, { recursive: true });
 
-    writeSchema(bundledDir, "spec-driven");
-    writeSchema(path.join(projectRoot, "schemas"), "custom-team");
+    writeSchema(bundledDir, 'spec-driven');
+    writeSchema(path.join(projectRoot, 'schemas'), 'custom-team');
 
     const schemas = discoverSchemaTemplates({ projectRoot, packageRoot, bundledDir });
     const ids = schemas.map((s) => s.id);
-    assert.deepEqual(ids, ["custom-team", "spec-driven"]);
+    assert.deepEqual(ids, ['custom-team', 'spec-driven']);
   }));
 
-test("discoverSchemaTemplates fails on duplicate IDs", () =>
+test('discoverSchemaTemplates fails on duplicate IDs', () =>
   withTempDir((root) => {
-    const projectRoot = path.join(root, "project");
-    const packageRoot = path.join(root, "package");
-    const bundledDir = path.join(packageRoot, "src", "schemas");
-    fs.mkdirSync(path.join(projectRoot, "schemas"), { recursive: true });
+    const projectRoot = path.join(root, 'project');
+    const packageRoot = path.join(root, 'package');
+    const bundledDir = path.join(packageRoot, 'src', 'schemas');
+    fs.mkdirSync(path.join(projectRoot, 'schemas'), { recursive: true });
     fs.mkdirSync(bundledDir, { recursive: true });
 
-    writeSchema(bundledDir, "spec-driven");
-    writeSchema(path.join(projectRoot, "schemas"), "spec-driven");
+    writeSchema(bundledDir, 'spec-driven');
+    writeSchema(path.join(projectRoot, 'schemas'), 'spec-driven');
 
     assert.throws(
       () => discoverSchemaTemplates({ projectRoot, packageRoot, bundledDir }),
-      /Schema ID conflict/
+      /Schema ID conflict/,
     );
   }));
 
-test("project config read/write round-trip", () =>
+test('project config read/write round-trip', () =>
   withTempDir((projectRoot) => {
-    writeProjectConfig(projectRoot, { defaultSchemaTemplateId: "devops-platform" });
+    writeProjectConfig(projectRoot, { defaultSchemaTemplateId: 'devops-platform' });
     const cfg = readProjectConfig(projectRoot);
-    assert.equal(cfg.defaultSchemaTemplateId, "devops-platform");
+    assert.equal(cfg.defaultSchemaTemplateId, 'devops-platform');
   }));

package/scripts/install-environments.js

@@ -17,7 +17,14 @@ function parseTools(value) {
   const raw = (value ?? 'all').trim().toLowerCase();
   if (raw === 'none') return [];
   if (raw === 'all') return [...SUPPORTED_TOOLS];
-  return [...new Set(raw.split(',').map(p => normalizeToolId(p.trim())).filter(Boolean))];
+  return [
+    ...new Set(
+      raw
+        .split(',')
+        .map((p) => normalizeToolId(p.trim()))
+        .filter(Boolean),
+    ),
+  ];
 }
 
 function defaultCommandExists(command) {
@@ -36,7 +43,7 @@ function buildDetectionContext(projectRoot, overrides = {}) {
 }
 
 function createDetectedEnvironment(id, signals) {
-  const detected = signals.some(signal => signal.present);
+  const detected = signals.some((signal) => signal.present);
   return { id, detected, signals };
 }
 
@@ -46,7 +53,11 @@ function detectCodex(context) {
     : path.join(context.homedir, '.codex');
   return createDetectedEnvironment('codex', [
     { kind: 'binary', name: 'codex', present: context.commandExists('codex') },
-    { kind: 'directory', name: path.join(context.projectRoot, '.codex'), present: context.pathExists(path.join(context.projectRoot, '.codex')) },
+    {
+      kind: 'directory',
+      name: path.join(context.projectRoot, '.codex'),
+      present: context.pathExists(path.join(context.projectRoot, '.codex')),
+    },
     { kind: 'directory', name: codexHome, present: context.pathExists(codexHome) },
   ]);
 }
@@ -54,8 +65,16 @@ function detectCodex(context) {
 function detectClaudeCode(context) {
   return createDetectedEnvironment('claudecode', [
     { kind: 'binary', name: 'claude', present: context.commandExists('claude') },
-    { kind: 'directory', name: path.join(context.projectRoot, '.claude'), present: context.pathExists(path.join(context.projectRoot, '.claude')) },
-    { kind: 'directory', name: path.join(context.homedir, '.claude'), present: context.pathExists(path.join(context.homedir, '.claude')) },
+    {
+      kind: 'directory',
+      name: path.join(context.projectRoot, '.claude'),
+      present: context.pathExists(path.join(context.projectRoot, '.claude')),
+    },
+    {
+      kind: 'directory',
+      name: path.join(context.homedir, '.claude'),
+      present: context.pathExists(path.join(context.homedir, '.claude')),
+    },
   ]);
 }
 
@@ -69,13 +88,13 @@ function getEnvironmentDetectors() {
 function detectEnvironments(projectRoot, overrides = {}) {
   const context = buildDetectionContext(projectRoot, overrides);
   const detectors = getEnvironmentDetectors();
-  return SUPPORTED_TOOLS.map(tool => detectors[tool].detect(context));
+  return SUPPORTED_TOOLS.map((tool) => detectors[tool].detect(context));
 }
 
 function detectInstalledTools(projectRoot, overrides = {}) {
   return detectEnvironments(projectRoot, overrides)
-    .filter(result => result.detected)
-    .map(result => result.id);
+    .filter((result) => result.detected)
+    .map((result) => result.id);
 }
 
 function getToolAdapters() {

package/scripts/install-environments.test.js

@@ -13,7 +13,7 @@ const HOME_DIR = '/home/tester';
 
 function detectionHarness({ commands = [], paths = [] } = {}) {
   const commandSet = new Set(commands);
-  const pathSet = new Set(paths.map(p => path.resolve(p)));
+  const pathSet = new Set(paths.map((p) => path.resolve(p)));
   return {
     commandExists: (command) => commandSet.has(command),
     pathExists: (targetPath) => pathSet.has(path.resolve(targetPath)),
@@ -23,23 +23,32 @@ function detectionHarness({ commands = [], paths = [] } = {}) {
 }
 
 test('detectInstalledTools returns claudecode when only Claude signals are present', () => {
-  const detected = detectInstalledTools(PROJECT_ROOT, detectionHarness({
-    commands: ['claude'],
-  }));
+  const detected = detectInstalledTools(
+    PROJECT_ROOT,
+    detectionHarness({
+      commands: ['claude'],
+    }),
+  );
   assert.deepEqual(detected, ['claudecode']);
 });
 
 test('detectInstalledTools returns codex when only Codex signals are present', () => {
-  const detected = detectInstalledTools(PROJECT_ROOT, detectionHarness({
-    commands: ['codex'],
-  }));
+  const detected = detectInstalledTools(
+    PROJECT_ROOT,
+    detectionHarness({
+      commands: ['codex'],
+    }),
+  );
   assert.deepEqual(detected, ['codex']);
 });
 
 test('detectInstalledTools returns both tools when both signals are present', () => {
-  const detected = detectInstalledTools(PROJECT_ROOT, detectionHarness({
-    commands: ['codex', 'claude'],
-  }));
+  const detected = detectInstalledTools(
+    PROJECT_ROOT,
+    detectionHarness({
+      commands: ['codex', 'claude'],
+    }),
+  );
   assert.deepEqual(detected, ['codex', 'claudecode']);
 });
 

package/scripts/install-skills.js

@@ -2,15 +2,11 @@
 
 const path = require('path');
 const fs = require('fs');
-const {
-  parseTools,
-  getToolAdapter,
-  detectEnvironments,
-} = require('./install-environments');
+const { parseTools, getToolAdapter, detectEnvironments } = require('./install-environments');
 
 const MANAGED_BEGIN = '<!-- DEVFLOW:BEGIN ';
 const MANAGED_END = '<!-- DEVFLOW:END ';
-const COMMAND_SET = ['new', 'continue', 'status', 'promote', 'develop', 'archive'];
+const COMMAND_SET = ['new', 'continue', 'status', 'promote', 'develop', 'archive', 'schema'];
 
 function resolveToolDirs(projectRoot, tool) {
   return getToolAdapter(tool).resolveTargets(projectRoot);
@@ -138,6 +134,44 @@ function renderSkill(tool, command, markerId) {
       '4. Call `archive_spec`.',
       '5. Report success and the archive path.',
     ],
+    schema: [
+      `# Skill: /df:schema`,
+      '',
+      `Use this skill to interactively create a custom DevFlow schema in ${agentName}.`,
+      '',
+      '## Steps (in order)',
+      '',
+      '1. Call `list_schemas` and show the user what schemas are already available.',
+      '   If one fits their needs, suggest using it directly.',
+      '2. Ask what kind of project/workflow they need (e.g. mobile app, ML pipeline,',
+      '   infrastructure, documentation, data engineering, security review, etc.).',
+      '3. Based on the project type, ask which artifacts/documents their workflow',
+      '   should include. Suggest sensible defaults. Common options:',
+      '   - Proposal / RFC',
+      '   - Requirements / Specifications',
+      '   - Architecture / Design doc',
+      '   - Security review',
+      '   - Testing plan / Test strategy',
+      '   - Migration plan',
+      '   - Deployment / Runbook',
+      '   - Implementation tasks',
+      '4. Design the artifact dependency DAG — which artifacts must be approved',
+      '   before others can be written. Present the DAG to the user for confirmation.',
+      '5. Ask about quality rules:',
+      '   - RFC 2119 keywords enforced (MUST/SHOULD/MAY)?',
+      '   - Minimum scenarios per requirement (suggest 1-2)?',
+      '6. Generate well-structured markdown templates for each artifact.',
+      '7. Call `create_schema` with name, artifacts, qualityRules, apply, and templates.',
+      '8. Report the schema was created and how to use it:',
+      '   - `create_spec` with `schema: "<name>"`',
+      '   - Or set as default in `devflow/project-config.json`',
+      '',
+      '## Guidelines',
+      '- Keep artifact IDs short and kebab-case (e.g. "security-review", "test-plan")',
+      '- Template filenames should match: `<artifact-id>.md`',
+      '- Always include a final "tasks" artifact that depends on the key artifacts',
+      '- The `apply.requires` should include at minimum the tasks artifact',
+    ],
   };
 
   const lines = bodies[command];
@@ -147,9 +181,10 @@ function renderSkill(tool, command, markerId) {
 
 function renderCommand(tool, command, markerId) {
   const commandName = `/df:${command}`;
-  const codexHeader = tool === 'codex'
-    ? ['---', `description: DevFlow ${commandName} workflow action`, '---', '']
-    : [];
+  const codexHeader =
+    tool === 'codex'
+      ? ['---', `description: DevFlow ${commandName} workflow action`, '---', '']
+      : [];
 
   const bodies = {
     new: [
@@ -262,6 +297,24 @@ function renderCommand(tool, command, markerId) {
       '4. Call `archive_spec`.',
       '5. Report success and the archive path.',
     ],
+    schema: [
+      `# ${commandName}`,
+      '',
+      'Interactively create a custom DevFlow schema.',
+      '',
+      '## Steps (in order)',
+      '',
+      '1. Call `list_schemas` and show available schemas. If one fits, suggest it.',
+      '2. Ask what kind of project/workflow the user needs.',
+      '3. Ask which artifacts/documents their workflow should include.',
+      '4. Design the artifact dependency DAG. Present it for confirmation.',
+      '5. Ask about quality rules (RFC 2119, min scenarios per requirement).',
+      '6. Generate markdown templates for each artifact.',
+      '7. Call `create_schema` with name, artifacts, qualityRules, apply, and templates.',
+      '8. Report the schema was created and how to use it:',
+      '   - `create_spec` with `schema: "<name>"`',
+      '   - Or set as default in `devflow/project-config.json`',
+    ],
   };
 
   const bodyLines = bodies[command];
@@ -273,7 +326,7 @@ function replaceManagedSection(existing, markerId, nextContent) {
   const escaped = markerId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   const pattern = new RegExp(
     `<!-- DEVFLOW:BEGIN ${escaped} -->[\\s\\S]*?<!-- DEVFLOW:END ${escaped} -->\\n?`,
-    'm'
+    'm',
   );
   if (!pattern.test(existing)) return null;
   return existing.replace(pattern, nextContent);
@@ -300,7 +353,9 @@ function buildAssets(projectRoot, tools, delivery) {
       const commandMarker = `${tool}:command:df-${command}`;
       if (delivery !== 'commands') {
         assets.push({
-          tool, kind: 'skill', command,
+          tool,
+          kind: 'skill',
+          command,
           outputPath: path.join(dirs.skillsDir, `df-${command}.md`),
           markerId: skillMarker,
           content: renderSkill(tool, command, skillMarker),
@@ -308,7 +363,9 @@ function buildAssets(projectRoot, tools, delivery) {
       }
       if (delivery !== 'skills') {
         assets.push({
-          tool, kind: 'command', command,
+          tool,
+          kind: 'command',
+          command,
           outputPath: path.join(dirs.commandsDir, `df-${command}.md`),
           markerId: commandMarker,
           content: renderCommand(tool, command, commandMarker),
@@ -329,7 +386,7 @@ function selectTools(projectRoot, options) {
   } else if (options.tools !== undefined) {
     selectedTools = parseTools(options.tools);
   } else if (autodetect) {
-    selectedTools = detection.filter(d => d.detected).map(d => d.id);
+    selectedTools = detection.filter((d) => d.detected).map((d) => d.id);
   } else {
     selectedTools = parseTools('all');
   }
@@ -354,17 +411,17 @@ function installSkills(projectRoot, options = {}) {
     dryRun,
     autodetect: selection.autodetect,
     selectedTools: selection.selectedTools,
-    environments: selection.detection.map(d => ({
+    environments: selection.detection.map((d) => ({
       tool: d.id,
       detected: d.detected,
-      status: selection.selectedTools.includes(d.id)
-        ? (dryRun ? 'planned' : 'pending')
-        : 'skipped',
+      status: selection.selectedTools.includes(d.id) ? (dryRun ? 'planned' : 'pending') : 'skipped',
       reason: selection.selectedTools.includes(d.id)
         ? undefined
-        : (selection.autodetect && options.tools === undefined && !options.only
-          ? (d.detected ? 'not-selected' : 'not-detected')
-          : 'not-selected'),
+        : selection.autodetect && options.tools === undefined && !options.only
+          ? d.detected
+            ? 'not-selected'
+            : 'not-detected'
+          : 'not-selected',
       created: 0,
       updated: 0,
       skipped: 0,
@@ -378,7 +435,7 @@ function installSkills(projectRoot, options = {}) {
 
   for (const asset of assets) {
     const { outputPath, markerId, content, tool } = asset;
-    const envReport = report.environments.find(e => e.tool === tool);
+    const envReport = report.environments.find((e) => e.tool === tool);
     const displayPath = path.relative(projectRoot, outputPath);
     try {
       const alreadyExists = exists(outputPath);
@@ -393,7 +450,11 @@ function installSkills(projectRoot, options = {}) {
             }
             report.updated++;
             if (envReport) envReport.updated++;
-            report.results.push({ ...asset, path: displayPath, action: dryRun ? 'would_update' : 'updated' });
+            report.results.push({
+              ...asset,
+              path: displayPath,
+              action: dryRun ? 'would_update' : 'updated',
+            });
           } else {
             report.skipped++;
             if (envReport) envReport.skipped++;
@@ -403,7 +464,7 @@ function installSkills(projectRoot, options = {}) {
         }
 
         const ownershipError = new Error(
-          `Refusing to modify unmanaged file for ${tool}: ${displayPath}`
+          `Refusing to modify unmanaged file for ${tool}: ${displayPath}`,
         );
         ownershipError.code = 'UNMANAGED_FILE';
         throw ownershipError;
@@ -414,7 +475,11 @@ function installSkills(projectRoot, options = {}) {
       }
       report.created++;
       if (envReport) envReport.created++;
-      report.results.push({ ...asset, path: displayPath, action: dryRun ? 'would_create' : 'created' });
+      report.results.push({
+        ...asset,
+        path: displayPath,
+        action: dryRun ? 'would_create' : 'created',
+      });
     } catch (error) {
       report.failed++;
       if (envReport) envReport.failed++;
@@ -432,7 +497,8 @@ function installSkills(projectRoot, options = {}) {
     if (!selection.selectedTools.includes(envReport.tool)) continue;
     if (envReport.failed > 0) {
       envReport.status = 'failed';
-      envReport.reason = envReport.created + envReport.updated > 0 ? 'partial-failure' : 'install-failed';
+      envReport.reason =
+        envReport.created + envReport.updated > 0 ? 'partial-failure' : 'install-failed';
     } else if (dryRun) {
       envReport.status = 'planned';
     } else {
@@ -449,22 +515,29 @@ function printReport(report) {
     for (const env of report.environments) {
       const statusDetails = env.reason ? `${env.status} (${env.reason})` : env.status;
       const detectedText = env.detected ? 'detected' : 'not detected';
-      console.log(`  - ${env.tool}: ${statusDetails}; ${detectedText}; created=${env.created} updated=${env.updated} skipped=${env.skipped} failed=${env.failed}`);
+      console.log(
+        `  - ${env.tool}: ${statusDetails}; ${detectedText}; created=${env.created} updated=${env.updated} skipped=${env.skipped} failed=${env.failed}`,
+      );
     }
     console.log('');
   }
 
   for (const r of report.results) {
     const icon =
-      r.action === 'created' || r.action === 'would_create' ? '✓' :
-      r.action === 'updated' || r.action === 'would_update' ? '↻' :
-      r.action === 'failed' ? '✗' :
-      '–';
+      r.action === 'created' || r.action === 'would_create'
+        ? '✓'
+        : r.action === 'updated' || r.action === 'would_update'
+          ? '↻'
+          : r.action === 'failed'
+            ? '✗'
+            : '–';
     const errorSuffix = r.action === 'failed' ? ` - ${r.error}` : '';
     console.log(`  ${icon} [${r.tool}] ${r.kind} ${r.path} (${r.action})${errorSuffix}`);
   }
   const mode = report.dryRun ? ' (dry-run)' : '';
-  console.log(`\n  ${report.created} created, ${report.updated} updated, ${report.skipped} skipped, ${report.failed} failed${mode}`);
+  console.log(
+    `\n  ${report.created} created, ${report.updated} updated, ${report.skipped} skipped, ${report.failed} failed${mode}`,
+  );
 }
 
 // CLI usage: node scripts/install-skills.js [--tools all|codex|claudecode] [--delivery both|skills|commands] [--force]

package/scripts/install-skills.test.js

@@ -82,7 +82,7 @@ test('installer refuses to overwrite unmanaged files even with force', () => {
       });
 
       assert.ok(report.failed >= 1);
-      const failedNewSkill = report.results.find(r => r.path.endsWith('.codex/skills/df-new.md'));
+      const failedNewSkill = report.results.find((r) => r.path.endsWith('.codex/skills/df-new.md'));
       assert.ok(failedNewSkill);
       assert.equal(failedNewSkill.errorCode, 'UNMANAGED_FILE');
       assert.equal(fs.readFileSync(target, 'utf-8'), '# user owned file\n');
@@ -106,8 +106,8 @@ test('installer autodetect default installs only detected environments', () => {
       });
 
       assert.deepEqual(report.selectedTools, ['codex']);
-      const codexSummary = report.environments.find(e => e.tool === 'codex');
-      const claudeSummary = report.environments.find(e => e.tool === 'claudecode');
+      const codexSummary = report.environments.find((e) => e.tool === 'codex');
+      const claudeSummary = report.environments.find((e) => e.tool === 'claudecode');
       assert.equal(codexSummary.status, 'installed');
       assert.equal(claudeSummary.status, 'skipped');
       assert.equal(claudeSummary.reason, 'not-detected');
@@ -128,7 +128,7 @@ test('dry-run reports planned actions without writing files', () => {
       });
       assert.equal(report.dryRun, true);
       assert.ok(report.created > 0);
-      assert.ok(report.results.some(r => r.action === 'would_create'));
+      assert.ok(report.results.some((r) => r.action === 'would_create'));
       const expectedPath = path.join(projectRoot, '.codex', 'skills', 'df-new.md');
       assert.equal(fs.existsSync(expectedPath), false);
     });
@@ -152,8 +152,8 @@ test('disabling autodetect targets all supported tools by default', () => {
       });
 
       assert.deepEqual(report.selectedTools.sort(), ['claudecode', 'codex']);
-      const codexSummary = report.environments.find(e => e.tool === 'codex');
-      const claudeSummary = report.environments.find(e => e.tool === 'claudecode');
+      const codexSummary = report.environments.find((e) => e.tool === 'codex');
+      const claudeSummary = report.environments.find((e) => e.tool === 'claudecode');
       assert.equal(codexSummary.status, 'installed');
       assert.equal(claudeSummary.status, 'installed');
     });

package/src/app/api/agents/route.ts

@@ -1,5 +1,5 @@
-import { NextResponse } from "next/server";
-import { getAgentCount, getAgentList } from "@/websocket/server";
+import { NextResponse } from 'next/server';
+import { getAgentCount, getAgentList } from '@/websocket/server';
 
 export async function GET() {
   const agents = getAgentList();

package/src/app/api/projects/[id]/route.ts

@@ -1,11 +1,8 @@
-import { NextResponse } from "next/server";
-import { getDb, schema } from "@/db";
-import { eq } from "drizzle-orm";
+import { NextResponse } from 'next/server';
+import { getDb, schema } from '@/db';
+import { eq } from 'drizzle-orm';
 
-export async function DELETE(
-  request: Request,
-  { params }: { params: Promise<{ id: string }> }
-) {
+export async function DELETE(request: Request, { params }: { params: Promise<{ id: string }> }) {
   try {
     const { id } = await params;
     const db = await getDb();
@@ -17,7 +14,7 @@ export async function DELETE(
       .limit(1);
 
     if (project.length === 0) {
-      return NextResponse.json({ error: "Project not found" }, { status: 404 });
+      return NextResponse.json({ error: 'Project not found' }, { status: 404 });
     }
 
     const projectTasks = await db
@@ -34,18 +31,15 @@ export async function DELETE(
 
     return NextResponse.json({ success: true });
   } catch (error) {
-    console.error("Delete project error:", error);
+    console.error('Delete project error:', error);
     return NextResponse.json(
-      { error: "Failed to delete project", details: String(error) },
-      { status: 500 }
+      { error: 'Failed to delete project', details: String(error) },
+      { status: 500 },
     );
   }
 }
 
-export async function PATCH(
-  request: Request,
-  { params }: { params: Promise<{ id: string }> }
-) {
+export async function PATCH(request: Request, { params }: { params: Promise<{ id: string }> }) {
   try {
     const { id } = await params;
     const body = await request.json();
@@ -67,9 +61,6 @@ export async function PATCH(
 
     return NextResponse.json(updatedProject[0]);
   } catch (error) {
-    return NextResponse.json(
-      { error: "Failed to update project" },
-      { status: 500 }
-    );
+    return NextResponse.json({ error: 'Failed to update project' }, { status: 500 });
   }
 }

package/src/app/api/projects/route.ts

@@ -1,18 +1,12 @@
-import { NextResponse } from "next/server";
-import { getDb, schema } from "@/db";
+import { NextResponse } from 'next/server';
+import { getDb, schema } from '@/db';
 
 export async function GET() {
   try {
     const db = await getDb();
-    const projects = await db
-      .select()
-      .from(schema.projects)
-      .orderBy(schema.projects.createdAt);
+    const projects = await db.select().from(schema.projects).orderBy(schema.projects.createdAt);
     return NextResponse.json(projects);
   } catch (error) {
-    return NextResponse.json(
-      { error: "Failed to fetch projects" },
-      { status: 500 }
-    );
+    return NextResponse.json({ error: 'Failed to fetch projects' }, { status: 500 });
   }
 }