@programinglive/dev-workflow-mcp-server 1.5.1 → 1.5.3

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [1.5.3](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.5.2...v1.5.3) (2025-12-05)
+
+
+### 🐛 Bug Fixes
+
+* correct package.json version from null to 1.5.2 for npm publish ([be60c99](https://github.com/programinglive/dev-workflow-mcp-server/commit/be60c99f1e79cdaf5d3b9cb7c780edd30356f420))
+* **news:** improve error handling and form accessibility ([5e0a1a8](https://github.com/programinglive/dev-workflow-mcp-server/commit/5e0a1a83ae18054f967ff9041c7ed81fd7d6d4eb))
+* switch to static export for Netlify deployment ([acddfd7](https://github.com/programinglive/dev-workflow-mcp-server/commit/acddfd78da86859febdb1c46b04a5e79fd8f176f))
+
+
+### 🧹 Chores
+
+* **release:** null 🚀 ([55d7f99](https://github.com/programinglive/dev-workflow-mcp-server/commit/55d7f9980ea8f188d284facb7c9d1d5d4a6d6210))
+* **release:** prepare patch release 1.5.3 ([5b92c42](https://github.com/programinglive/dev-workflow-mcp-server/commit/5b92c4215e4188a3dc6714d3f2999c65f460d2c9))
+
+### [1.5.2](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.5.1...v1.5.2) (2025-12-02)
+
 ### [1.5.1](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.5.0...v1.5.1) (2025-12-02)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@programinglive/dev-workflow-mcp-server",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "MCP server to enforce development workflow discipline",
   "homepage": "https://devworkflow.programinglive.com/",
   "mcpName": "io.github.programinglive/dev-workflow-mcp-server",
@@ -22,10 +22,10 @@
     "check": "node --check index.js",
     "prepare": "husky",
     "postinstall": "node install.js",
-    "release": "node scripts/release.cjs",
-    "release:major": "node release-wrapper.js major",
-    "release:minor": "node release-wrapper.js minor",
-    "release:patch": "node release-wrapper.js patch",
+    "release": "node scripts/release.js",
+    "release:major": "node scripts/release.js major",
+    "release:minor": "node scripts/release.js minor",
+    "release:patch": "node scripts/release.js patch",
     "web": "npm start --prefix web"
   },
   "keywords": [
@@ -38,7 +38,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/programinglive/dev-workflow-mcp-server.git"
+    "url": "git+https://github.com/programinglive/dev-workflow-mcp-server.git"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
@@ -52,8 +52,8 @@
     "access": "public"
   },
   "devDependencies": {
-    "@commitlint/cli": "^20.1.0",
-    "@commitlint/config-conventional": "^20.0.0",
+    "@commitlint/cli": "^20.2.0",
+    "@commitlint/config-conventional": "^20.2.0",
     "@programinglive/commiter": "^1.1.8",
     "autoprefixer": "^10.4.22",
     "husky": "^9.1.7",

package/scripts/release.js

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const { updateReleaseNotes } = require('./update-release-notes');
+
+const fsFokPreloadPath = path.join(__dirname, 'preload', 'fs-f-ok.cjs');
+const FS_FOK_PRELOAD_FLAG = buildPreloadFlag(fsFokPreloadPath);
+
+require('./preload/fs-f-ok.cjs');
+
+const VALID_RELEASE_TYPES = new Set([
+  'major',
+  'minor',
+  'patch',
+  'premajor',
+  'preminor',
+  'prepatch',
+  'prerelease'
+]);
+
+const SEMVER_REGEX = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+
+const LOCKFILE_PREFERENCES = [
+  { manager: 'pnpm', file: 'pnpm-lock.yaml' },
+  { manager: 'yarn', file: 'yarn.lock' },
+  { manager: 'bun', file: 'bun.lockb' },
+  { manager: 'npm', file: 'package-lock.json' }
+];
+
+function getCliArguments(argv = process.argv) {
+  const rawArgs = argv.slice(2);
+  if (rawArgs.length === 0) {
+    return { releaseType: undefined, extraArgs: [] };
+  }
+
+  if (rawArgs[0].startsWith('-')) {
+    return { releaseType: undefined, extraArgs: rawArgs };
+  }
+
+  const [firstArg, ...rest] = rawArgs;
+  return { releaseType: firstArg, extraArgs: rest };
+}
+
+function getNpmRunArgument(env = process.env) {
+  try {
+    const npmArgs = JSON.parse(env.npm_config_argv || '{}');
+    const original = npmArgs.original || [];
+    const releaseIndex = original.lastIndexOf('release');
+    if (releaseIndex !== -1) {
+      return original[releaseIndex + 1];
+    }
+  } catch (error) {
+    // Ignore JSON parsing issues and fall back to defaults
+  }
+  return undefined;
+}
+
+function buildStandardVersionArgs({ releaseType, extraArgs }) {
+  const args = [];
+  if (releaseType) {
+    const normalized = releaseType.trim();
+    const isValid = VALID_RELEASE_TYPES.has(normalized) || SEMVER_REGEX.test(normalized);
+    if (!isValid) {
+      const allowed = Array.from(VALID_RELEASE_TYPES).join(', ');
+      throw new Error(`Unknown release type "${normalized}". Use one of ${allowed} or a valid semver version.`);
+    }
+    args.push('--release-as', normalized);
+  }
+
+  if (Array.isArray(extraArgs) && extraArgs.length > 0) {
+    args.push(...extraArgs);
+  }
+
+  return args;
+}
+
+function loadPackageJson(cwd = process.cwd()) {
+  try {
+    const packageJsonPath = path.join(cwd, 'package.json');
+    const contents = fs.readFileSync(packageJsonPath, 'utf8');
+    return JSON.parse(contents);
+  } catch (error) {
+    return null;
+  }
+}
+
+function detectPackageManager({ env = process.env, cwd = process.cwd() } = {}) {
+  const userAgent = env.npm_config_user_agent || '';
+  if (userAgent.startsWith('pnpm/')) return 'pnpm';
+  if (userAgent.startsWith('yarn/')) return 'yarn';
+  if (userAgent.startsWith('bun/')) return 'bun';
+
+  for (const { manager, file } of LOCKFILE_PREFERENCES) {
+    if (fs.existsSync(path.join(cwd, file))) {
+      return manager;
+    }
+  }
+
+  return 'npm';
+}
+
+function buildTestCommand(packageManager) {
+  switch (packageManager) {
+    case 'pnpm':
+      return { command: 'pnpm', args: ['test'] };
+    case 'yarn':
+      return { command: 'yarn', args: ['test'] };
+    case 'bun':
+      return { command: 'bun', args: ['test'] };
+    default:
+      return { command: 'npm', args: ['test'] };
+  }
+}
+
+function runProjectTests({ spawn = spawnSync, env = process.env, cwd = process.cwd() } = {}) {
+  const packageJson = loadPackageJson(cwd);
+  const scripts = packageJson && packageJson.scripts ? packageJson.scripts : {};
+
+  if (!scripts.test) {
+    console.log('ℹ️  Skipping tests: no "test" script detected in package.json');
+    return { status: 0 };
+  }
+
+  const packageManager = detectPackageManager({ env, cwd });
+  const { command, args } = buildTestCommand(packageManager);
+
+  console.log(`🧪 Running tests with ${packageManager} ${args.join(' ')}`.trim());
+  return spawn(command, args, {
+    stdio: 'inherit',
+    env
+  });
+}
+
+function runRelease({
+  argv = process.argv,
+  env = process.env,
+  spawn = spawnSync,
+  cwd = process.cwd(),
+  dependencies = {}
+} = {}) {
+  const { releaseType: cliReleaseType, extraArgs } = getCliArguments(argv);
+  const inferredReleaseType = cliReleaseType || getNpmRunArgument(env);
+  const standardVersionArgs = buildStandardVersionArgs({
+    releaseType: inferredReleaseType,
+    extraArgs
+  });
+
+  const checkWorkingTreeClean = dependencies.isWorkingTreeClean || (() => isWorkingTreeClean({ cwd }));
+  const workingTreeClean = checkWorkingTreeClean();
+  if (!workingTreeClean) {
+    throw new Error('Working tree has uncommitted changes. Commit or stash before running release.');
+  }
+
+  const testResult = runProjectTests({ spawn, env });
+  if (testResult && typeof testResult.status === 'number' && testResult.status !== 0) {
+    return testResult;
+  }
+
+  const standardVersionBin = require.resolve('standard-version/bin/cli.js');
+  const childEnv = appendPreloadToNodeOptions(env, FS_FOK_PRELOAD_FLAG);
+  const releaseResult = spawn(process.execPath, [standardVersionBin, ...standardVersionArgs], {
+    stdio: 'inherit',
+    env: childEnv,
+    cwd
+  });
+
+  if (releaseResult && typeof releaseResult.status === 'number' && releaseResult.status !== 0) {
+    return releaseResult;
+  }
+
+  const releaseNotesPath = dependencies.releaseNotesPath || path.join('docs', 'release-notes', 'RELEASE_NOTES.md');
+  const updateNotes = dependencies.updateReleaseNotes || ((options = {}) => updateReleaseNotes({ rootDir: cwd, ...options }));
+
+  let notesUpdated = false;
+  try {
+    notesUpdated = updateNotes();
+  } catch (error) {
+    console.warn(`⚠️  Skipping release notes update: ${error.message}`);
+  }
+
+  if (notesUpdated) {
+    const gitAddResult = spawnSync('git', ['add', releaseNotesPath], { stdio: 'inherit', cwd });
+    if (!gitAddResult || typeof gitAddResult.status !== 'number' || gitAddResult.status !== 0) {
+      console.warn('⚠️  Release notes updated but failed to stage. Please add manually: git add ' + releaseNotesPath);
+    }
+  }
+
+  return releaseResult;
+}
+
+if (require.main === module) {
+  try {
+    const result = runRelease();
+    if (result.status !== 0) {
+      process.exit(result.status ?? 1);
+    }
+  } catch (error) {
+    console.error(`❌ ${error.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  VALID_RELEASE_TYPES,
+  SEMVER_REGEX,
+  getCliArguments,
+  getNpmRunArgument,
+  buildStandardVersionArgs,
+  loadPackageJson,
+  detectPackageManager,
+  runProjectTests,
+  runRelease,
+  isWorkingTreeClean
+};
+
+function buildPreloadFlag(filePath) {
+  const resolved = path.resolve(filePath);
+  const escaped = resolved.includes(' ')
+    ? `"${resolved.replace(/"/g, '\"')}"`
+    : resolved;
+  return `--require ${escaped}`;
+}
+
+function appendPreloadToNodeOptions(env, preloadFlag) {
+  const nextEnv = { ...env };
+  const existing = typeof nextEnv.NODE_OPTIONS === 'string' ? nextEnv.NODE_OPTIONS.trim() : '';
+  nextEnv.NODE_OPTIONS = existing ? `${existing} ${preloadFlag}` : preloadFlag;
+  return nextEnv;
+}
+
+function isWorkingTreeClean({ cwd = process.cwd() } = {}) {
+  const result = spawnSync('git', ['status', '--porcelain'], {
+    cwd,
+    encoding: 'utf8'
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (typeof result.status === 'number' && result.status !== 0) {
+    const stderr = typeof result.stderr === 'string' ? result.stderr.trim() : '';
+    const message = stderr || 'Failed to determine working tree status.';
+    throw new Error(message);
+  }
+
+  const output = typeof result.stdout === 'string' ? result.stdout : '';
+  return output.trim().length === 0;
+}

package/scripts/update-release-notes.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+function updateReleaseNotes({
+  rootDir = process.cwd(),
+  releaseNotesRelativePath = path.join('docs', 'release-notes', 'RELEASE_NOTES.md'),
+  changelogRelativePath = 'CHANGELOG.md',
+  packageJsonRelativePath = 'package.json',
+  now = () => new Date()
+} = {}) {
+  const releaseNotesPath = path.join(rootDir, releaseNotesRelativePath);
+  if (!fs.existsSync(releaseNotesPath)) {
+    console.log(`ℹ️  Release notes file not found at ${releaseNotesPath}; skipping update.`);
+    return false;
+  }
+
+  const packageJsonPath = path.join(rootDir, packageJsonRelativePath);
+  if (!fs.existsSync(packageJsonPath)) {
+    console.log(`ℹ️  package.json not found at ${packageJsonPath}; skipping release notes update.`);
+    return false;
+  }
+
+  const changelogPath = path.join(rootDir, changelogRelativePath);
+  if (!fs.existsSync(changelogPath)) {
+    console.log(`ℹ️  CHANGELOG not found at ${changelogPath}; skipping release notes update.`);
+    return false;
+  }
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  const version = packageJson.version;
+  if (!version) {
+    console.log('ℹ️  package.json version is missing; skipping release notes update.');
+    return false;
+  }
+
+  const releaseNotesContent = fs.readFileSync(releaseNotesPath, 'utf8');
+  if (releaseNotesContent.includes(`| ${version} `) || releaseNotesContent.includes(`## ${version}`)) {
+    console.log(`ℹ️  Release notes already contain version ${version}; skipping.`);
+    return false;
+  }
+
+  const changelogContent = fs.readFileSync(changelogPath, 'utf8');
+  const changelogInfo = extractChangelogInfo({ changelogContent, version });
+
+  const releaseDate = changelogInfo.date || formatDate(now());
+  const highlight = changelogInfo.highlight || changelogInfo.heading || 'See CHANGELOG for details.';
+  const sectionHeading = changelogInfo.heading || '';
+  const detailBullets = Array.isArray(changelogInfo.bullets) && changelogInfo.bullets.length > 0
+    ? changelogInfo.bullets
+    : [highlight];
+
+  const updatedContent = insertReleaseNotesEntry({
+    content: releaseNotesContent,
+    version,
+    releaseDate,
+    highlight,
+    sectionHeading,
+    detailBullets
+  });
+
+  fs.writeFileSync(releaseNotesPath, updatedContent);
+  console.log(`✅ Added release notes entry for version ${version}.`);
+  return true;
+}
+
+function insertReleaseNotesEntry({ content, version, releaseDate, highlight, sectionHeading, detailBullets }) {
+  const lines = content.split('\n');
+  const headerSeparatorIndex = lines.findIndex((line) => line.trim().startsWith('|---------'));
+  if (headerSeparatorIndex === -1) {
+    throw new Error('Unable to locate release notes table header.');
+  }
+
+  const newRow = `| ${version} | ${releaseDate} | ${escapePipes(highlight)} |`;
+  lines.splice(headerSeparatorIndex + 1, 0, newRow);
+
+  const sectionLines = [];
+  sectionLines.push('');
+  const trimmedHeading = typeof sectionHeading === 'string' ? sectionHeading.trim() : '';
+  const headingSuffix = trimmedHeading ? ` – ${trimmedHeading}` : '';
+  sectionLines.push(`## ${version}${headingSuffix}`);
+  sectionLines.push('');
+  sectionLines.push(`Released on **${releaseDate}**.`);
+  sectionLines.push('');
+  for (const bullet of detailBullets) {
+    sectionLines.push(`- ${bullet}`);
+  }
+  sectionLines.push('');
+
+  const firstSectionIndex = lines.findIndex((line, idx) => idx > headerSeparatorIndex && line.startsWith('## '));
+  if (firstSectionIndex === -1) {
+    lines.push(...sectionLines);
+  } else {
+    lines.splice(firstSectionIndex, 0, ...sectionLines);
+  }
+
+  return lines.join('\n');
+}
+
+function extractChangelogInfo({ changelogContent, version }) {
+  const versionHeadingRegex = new RegExp(`^### \\[${escapeRegExp(version)}\\][^\n]*`, 'm');
+  const match = changelogContent.match(versionHeadingRegex);
+  if (!match) {
+    return {};
+  }
+
+  const headingIndex = match.index;
+  const rest = changelogContent.slice(headingIndex + match[0].length);
+  const nextVersionRegex = /^### \[[^\n]*\]/m;
+  const nextVersionMatch = nextVersionRegex.exec(rest);
+  const section = nextVersionMatch ? rest.slice(0, nextVersionMatch.index) : rest;
+
+  const dateMatch = match[0].match(/\((\d{4}-\d{2}-\d{2})\)/);
+  const date = dateMatch ? dateMatch[1] : undefined;
+
+  const categoryRegex = /^###\s+([^\n]+)$/m;
+  const categoryMatch = section.match(categoryRegex);
+  let heading;
+  if (categoryMatch) {
+    heading = sanitizeText(categoryMatch[1]);
+  }
+
+  const bullets = [];
+  const bulletRegex = /^\*\s+([^\n]+)$/gm;
+  let bulletMatch;
+  while ((bulletMatch = bulletRegex.exec(section)) !== null) {
+    const sanitized = sanitizeText(bulletMatch[1]);
+    if (!bullets.includes(sanitized)) {
+      bullets.push(sanitized);
+    }
+  }
+
+  const highlight = bullets.length > 0 ? bullets[0] : undefined;
+
+  return {
+    date,
+    highlight,
+    heading,
+    bullets
+  };
+}
+
+function sanitizeText(text) {
+  return text
+    .replace(/\[([^\]]+)\]\([^\)]+\)/g, '$1')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function escapePipes(text) {
+  return text.replace(/\|/g, '\\|');
+}
+
+function formatDate(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
+
+module.exports = {
+  updateReleaseNotes,
+  insertReleaseNotesEntry,
+  extractChangelogInfo,
+  sanitizeText,
+  escapePipes,
+  formatDate
+};
+
+if (require.main === module) {
+  try {
+    updateReleaseNotes();
+  } catch (error) {
+    console.error(`❌ Failed to update release notes: ${error.message}`);
+    process.exit(1);
+  }
+}

package/tests/build.test.js

@@ -47,27 +47,23 @@ test('build script exists in package.json', async () => {
   assert(pkg.scripts['build:server'].includes('vite build'));
 });
 
-test('Hero component fetches version dynamically', async () => {
+test('Hero component fetches npm downloads directly', async () => {
   const heroPath = path.join(process.cwd(), 'web', 'components', 'Hero.tsx');
   const heroContent = await readFile(heroPath, 'utf-8');
 
-  // Verify no hardcoded version strings
-  assert(!heroContent.includes('v1.3.12'), 'Hero should not have hardcoded v1.3.12');
-  assert(!heroContent.includes('"1.3.12"'), 'Hero should not have hardcoded "1.3.12"');
-
-  // Verify it fetches from /api/version
-  assert(heroContent.includes('fetch("/api/version")'), 'Hero should fetch version from API');
+  // Verify it fetches npm downloads directly from npm API
+  assert(heroContent.includes('api.npmjs.org'), 'Hero should fetch downloads from npm API');
   assert(heroContent.includes('useState<string | null>(null)'), 'Hero should have version state');
 });
 
-test('Netlify deployment configuration exists', async () => {
+test('Netlify deployment configuration exists for static export', async () => {
   const netlifyTomlPath = path.join(process.cwd(), 'web', 'netlify.toml');
   await access(netlifyTomlPath);
   
   const content = await readFile(netlifyTomlPath, 'utf-8');
   assert(content.includes('[build]'), 'netlify.toml should have build section');
   assert(content.includes('npm run build'), 'netlify.toml should have build command');
-  assert(content.includes('@netlify/plugin-nextjs'), 'netlify.toml should use Next.js plugin');
+  assert(content.includes('publish = "out"'), 'netlify.toml should publish out directory for static export');
 });
 
 test('Web package.json does not include better-sqlite3', async () => {
@@ -78,14 +74,10 @@ test('Web package.json does not include better-sqlite3', async () => {
   assert(!pkg.dependencies['better-sqlite3'], 'Web should not depend on better-sqlite3 for Netlify compatibility');
 });
 
-test('API routes return static data for Netlify deployment', async () => {
-  const summaryRoutePath = path.join(process.cwd(), 'web', 'app', 'api', 'summary', 'route.ts');
-  const historyRoutePath = path.join(process.cwd(), 'web', 'app', 'api', 'history', 'route.ts');
-  
-  const summaryContent = await readFile(summaryRoutePath, 'utf-8');
-  const historyContent = await readFile(historyRoutePath, 'utf-8');
+test('Next.js config uses static export for Netlify', async () => {
+  const nextConfigPath = path.join(process.cwd(), 'web', 'next.config.ts');
+  const content = await readFile(nextConfigPath, 'utf-8');
   
-  // Verify no database imports
-  assert(!summaryContent.includes('from "@/lib/db"'), 'Summary route should not import from db');
-  assert(!historyContent.includes('from "@/lib/db"'), 'History route should not import from db');
+  assert(content.includes("output: 'export'"), 'next.config.ts should use static export');
+  assert(content.includes('unoptimized: true'), 'next.config.ts should disable image optimization for static export');
 });

package/tests/patch-release.test.js

@@ -0,0 +1,7 @@
+import { test } from 'node:test'
+import { strict as assert } from 'node:assert'
+
+test('patch release preparation', () => {
+  // Verify we can prepare a patch release
+  assert.ok(true, 'Patch release 1.5.3 preparation test')
+})

package/web/components/Hero.tsx

@@ -10,15 +10,14 @@ export default function Hero() {
     const [version, setVersion] = useState<string | null>(null);
 
     useEffect(() => {
-        fetch("/api/npm-downloads")
+        // Fetch npm downloads directly from npm API
+        fetch("https://api.npmjs.org/downloads/point/last-month/@programinglive/dev-workflow-mcp-server")
             .then(res => res.json())
-            .then(data => setDownloads(data.downloads))
+            .then(data => setDownloads(data.downloads || 0))
             .catch(() => setDownloads(null));
 
-        fetch("/api/version")
-            .then(res => res.json())
-            .then(data => setVersion(data.version))
-            .catch(() => setVersion(null));
+        // Version is hardcoded for static export
+        setVersion("1.5.1");
     }, []);
 
     const formatDownloads = (num: number) => {

package/web/netlify.toml

@@ -1,6 +1,3 @@
 [build]
   command = "npm run build"
-  publish = ".next"
-
-[[plugins]]
-  package = "@netlify/plugin-nextjs"
+  publish = "out"

package/web/next.config.ts

@@ -1,7 +1,12 @@
 import type { NextConfig } from "next";
 
 const nextConfig: NextConfig = {
-  // Netlify handles the build output automatically
+  // Static export for Netlify deployment
+  output: 'export',
+  // Disable image optimization for static export
+  images: {
+    unoptimized: true,
+  },
 };
 
 export default nextConfig;

package/web/app/api/docs/route.ts

@@ -1,32 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-import { resolveDocContent, getAvailableDocs } from "@/lib/docs";
-
-export async function GET(request: NextRequest) {
-    const searchParams = request.nextUrl.searchParams;
-    const rawDocKey = searchParams.get("doc");
-    const availableDocs = getAvailableDocs();
-
-    if (!rawDocKey) {
-        return NextResponse.json({ docs: availableDocs });
-    }
-
-    const docKey = rawDocKey.trim();
-    const resolvedKey = availableDocs.find((key) => key.toLowerCase() === docKey.toLowerCase());
-
-    if (!resolvedKey) {
-        return NextResponse.json(
-            { error: "Document not found", requested: docKey, available: availableDocs },
-            { status: 404 }
-        );
-    }
-
-    const result = await resolveDocContent(resolvedKey);
-    if (!result.exists) {
-        return NextResponse.json(
-            { error: "Document asset is missing" },
-            { status: 500 }
-        );
-    }
-
-    return NextResponse.json({ doc: resolvedKey, content: result.content, format: result.format });
-}

package/web/app/api/history/route.ts

@@ -1,12 +0,0 @@
-import { NextResponse } from "next/server";
-
-export async function GET() {
-    // Return placeholder data - database integration not available in static deployment
-    return NextResponse.json({
-        data: [],
-        total: 0,
-        page: 1,
-        pageSize: 20,
-        totalPages: 1
-    });
-}

package/web/app/api/npm-downloads/route.ts

@@ -1,21 +0,0 @@
-import { NextResponse } from "next/server";
-
-export async function GET() {
-    try {
-        const packageName = "@programinglive/dev-workflow-mcp-server";
-        const response = await fetch(
-            `https://api.npmjs.org/downloads/point/last-month/${packageName}`,
-            { next: { revalidate: 3600 } } // Cache for 1 hour
-        );
-
-        if (!response.ok) {
-            return NextResponse.json({ downloads: 0 }, { status: 200 });
-        }
-
-        const data = await response.json();
-        return NextResponse.json({ downloads: data.downloads || 0 });
-    } catch (error) {
-        console.error("Error fetching npm downloads:", error);
-        return NextResponse.json({ downloads: 0 }, { status: 200 });
-    }
-}

package/web/app/api/summary/route.ts

@@ -1,13 +0,0 @@
-import { NextResponse } from "next/server";
-
-export async function GET() {
-    // Return placeholder data - database integration not available in static deployment
-    const summary = {
-        totalTasks: 0,
-        taskTypes: {},
-        lastActive: null,
-        recentTasks: [],
-        updatedAt: null,
-    };
-    return NextResponse.json({ summary });
-}

package/web/app/api/version/route.ts

@@ -1,8 +0,0 @@
-import { NextResponse } from "next/server";
-
-// Version is updated during build/release process
-const PACKAGE_VERSION = "1.5.1";
-
-export async function GET() {
-    return NextResponse.json({ version: PACKAGE_VERSION });
-}