refactoring the api endpoints to be separate files to reduce context usage

apps/server/src/routes/features/common.ts

@@ -0,0 +1,21 @@
+/**
+ * Common utilities for features routes
+ */
+
+import { createLogger } from "../../lib/logger.js";
+
+const logger = createLogger("Features");
+
+/**
+ * Get error message from error object
+ */
+export function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : "Unknown error";
+}
+
+/**
+ * Log error details consistently
+ */
+export function logError(error: unknown, context: string): void {
+  logger.error(`❌ ${context}:`, error);
+}

apps/server/src/routes/features/index.ts

@@ -0,0 +1,25 @@
+/**
+ * Features routes - HTTP API for feature management
+ */
+
+import { Router } from "express";
+import { FeatureLoader } from "../../services/feature-loader.js";
+import { createListHandler } from "./routes/list.js";
+import { createGetHandler } from "./routes/get.js";
+import { createCreateHandler } from "./routes/create.js";
+import { createUpdateHandler } from "./routes/update.js";
+import { createDeleteHandler } from "./routes/delete.js";
+import { createAgentOutputHandler } from "./routes/agent-output.js";
+
+export function createFeaturesRoutes(featureLoader: FeatureLoader): Router {
+  const router = Router();
+
+  router.post("/list", createListHandler(featureLoader));
+  router.post("/get", createGetHandler(featureLoader));
+  router.post("/create", createCreateHandler(featureLoader));
+  router.post("/update", createUpdateHandler(featureLoader));
+  router.post("/delete", createDeleteHandler(featureLoader));
+  router.post("/agent-output", createAgentOutputHandler(featureLoader));
+
+  return router;
+}

apps/server/src/routes/features/routes/agent-output.ts

@@ -0,0 +1,37 @@
+/**
+ * POST /agent-output endpoint - Get agent output for a feature
+ */
+
+import type { Request, Response } from "express";
+import { FeatureLoader } from "../../../services/feature-loader.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createAgentOutputHandler(featureLoader: FeatureLoader) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { projectPath, featureId } = req.body as {
+        projectPath: string;
+        featureId: string;
+      };
+
+      if (!projectPath || !featureId) {
+        res
+          .status(400)
+          .json({
+            success: false,
+            error: "projectPath and featureId are required",
+          });
+        return;
+      }
+
+      const content = await featureLoader.getAgentOutput(
+        projectPath,
+        featureId
+      );
+      res.json({ success: true, content });
+    } catch (error) {
+      logError(error, "Get agent output failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/features/routes/create.ts

@@ -0,0 +1,41 @@
+/**
+ * POST /create endpoint - Create a new feature
+ */
+
+import type { Request, Response } from "express";
+import {
+  FeatureLoader,
+  type Feature,
+} from "../../../services/feature-loader.js";
+import { addAllowedPath } from "../../../lib/security.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createCreateHandler(featureLoader: FeatureLoader) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { projectPath, feature } = req.body as {
+        projectPath: string;
+        feature: Partial<Feature>;
+      };
+
+      if (!projectPath || !feature) {
+        res
+          .status(400)
+          .json({
+            success: false,
+            error: "projectPath and feature are required",
+          });
+        return;
+      }
+
+      // Add project path to allowed paths
+      addAllowedPath(projectPath);
+
+      const created = await featureLoader.create(projectPath, feature);
+      res.json({ success: true, feature: created });
+    } catch (error) {
+      logError(error, "Create feature failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/features/routes/delete.ts

@@ -0,0 +1,34 @@
+/**
+ * POST /delete endpoint - Delete a feature
+ */
+
+import type { Request, Response } from "express";
+import { FeatureLoader } from "../../../services/feature-loader.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createDeleteHandler(featureLoader: FeatureLoader) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { projectPath, featureId } = req.body as {
+        projectPath: string;
+        featureId: string;
+      };
+
+      if (!projectPath || !featureId) {
+        res
+          .status(400)
+          .json({
+            success: false,
+            error: "projectPath and featureId are required",
+          });
+        return;
+      }
+
+      const success = await featureLoader.delete(projectPath, featureId);
+      res.json({ success });
+    } catch (error) {
+      logError(error, "Delete feature failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/features/routes/get.ts

@@ -0,0 +1,39 @@
+/**
+ * POST /get endpoint - Get a single feature
+ */
+
+import type { Request, Response } from "express";
+import { FeatureLoader } from "../../../services/feature-loader.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createGetHandler(featureLoader: FeatureLoader) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { projectPath, featureId } = req.body as {
+        projectPath: string;
+        featureId: string;
+      };
+
+      if (!projectPath || !featureId) {
+        res
+          .status(400)
+          .json({
+            success: false,
+            error: "projectPath and featureId are required",
+          });
+        return;
+      }
+
+      const feature = await featureLoader.get(projectPath, featureId);
+      if (!feature) {
+        res.status(404).json({ success: false, error: "Feature not found" });
+        return;
+      }
+
+      res.json({ success: true, feature });
+    } catch (error) {
+      logError(error, "Get feature failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/features/routes/list.ts

@@ -0,0 +1,32 @@
+/**
+ * POST /list endpoint - List all features for a project
+ */
+
+import type { Request, Response } from "express";
+import { FeatureLoader } from "../../../services/feature-loader.js";
+import { addAllowedPath } from "../../../lib/security.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createListHandler(featureLoader: FeatureLoader) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { projectPath } = req.body as { projectPath: string };
+
+      if (!projectPath) {
+        res
+          .status(400)
+          .json({ success: false, error: "projectPath is required" });
+        return;
+      }
+
+      // Add project path to allowed paths
+      addAllowedPath(projectPath);
+
+      const features = await featureLoader.getAll(projectPath);
+      res.json({ success: true, features });
+    } catch (error) {
+      logError(error, "List features failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/features/routes/update.ts

@@ -0,0 +1,40 @@
+/**
+ * POST /update endpoint - Update a feature
+ */
+
+import type { Request, Response } from "express";
+import {
+  FeatureLoader,
+  type Feature,
+} from "../../../services/feature-loader.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createUpdateHandler(featureLoader: FeatureLoader) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { projectPath, featureId, updates } = req.body as {
+        projectPath: string;
+        featureId: string;
+        updates: Partial<Feature>;
+      };
+
+      if (!projectPath || !featureId || !updates) {
+        res.status(400).json({
+          success: false,
+          error: "projectPath, featureId, and updates are required",
+        });
+        return;
+      }
+
+      const updated = await featureLoader.update(
+        projectPath,
+        featureId,
+        updates
+      );
+      res.json({ success: true, feature: updated });
+    } catch (error) {
+      logError(error, "Update feature failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}