forgedev 1.1.3 → 1.3.0

package/templates/ai/guardrails-ts/src/lib/ai/health.ts.template

@@ -0,0 +1,165 @@
+/**
+ * AI Health Check — Observability endpoint for AI system metrics.
+ *
+ * Compliance: NIST AI RMF Manage 3.2 (monitoring),
+ *             EU AI Act Art. 9 (risk management)
+ *
+ * Exposes metrics for monitoring dashboards and alerting:
+ * - Model availability and latency
+ * - Confidence score distribution
+ * - Human review trigger rate
+ * - Error rate and types
+ * - Token usage and cost estimation
+ *
+ * Mount this at /api/ai/health or similar endpoint.
+ */
+
+interface CallMetric {
+  timestamp: number;
+  model: string;
+  latencyMs: number;
+  confidence: number;
+  success: boolean;
+  tokenUsage?: { inputTokens: number; outputTokens: number };
+}
+
+class AIHealthMetrics {
+  private metrics: CallMetric[] = [];
+  private maxMetrics = 5000;
+
+  recordCall(metric: Omit<CallMetric, 'timestamp'>): void {
+    this.metrics.push({ ...metric, timestamp: Date.now() });
+    if (this.metrics.length > this.maxMetrics) {
+      this.metrics = this.metrics.slice(-this.maxMetrics);
+    }
+  }
+
+  /**
+   * Get AI health status for the health check endpoint.
+   */
+  getHealthStatus(windowMs = 3600_000): AIHealthStatus {
+    const cutoff = Date.now() - windowMs;
+    const recent = this.metrics.filter(m => m.timestamp >= cutoff);
+
+    if (recent.length === 0) {
+      return {
+        status: 'ok',
+        aiAvailable: true,
+        message: 'No AI calls in the monitoring window',
+        window: `${windowMs / 60_000}m`,
+        metrics: this.emptyMetrics(),
+        models: {},
+      };
+    }
+
+    const successes = recent.filter(m => m.success);
+    const errorRate = 1 - (successes.length / recent.length);
+    const avgConfidence = successes.length > 0
+      ? successes.reduce((s, m) => s + m.confidence, 0) / successes.length
+      : 0;
+    const avgLatency = recent.reduce((s, m) => s + m.latencyMs, 0) / recent.length;
+    const lowConfidenceRate = successes.filter(m => m.confidence < 0.7).length / Math.max(successes.length, 1);
+
+    // Determine overall status
+    let status: 'ok' | 'degraded' | 'unhealthy' = 'ok';
+    const warnings: string[] = [];
+
+    if (errorRate > 0.5) {
+      status = 'unhealthy';
+      warnings.push(`High error rate: ${(errorRate * 100).toFixed(1)}%`);
+    } else if (errorRate > 0.1) {
+      status = 'degraded';
+      warnings.push(`Elevated error rate: ${(errorRate * 100).toFixed(1)}%`);
+    }
+
+    if (avgConfidence < 0.5) {
+      status = status === 'ok' ? 'degraded' : status;
+      warnings.push(`Low average confidence: ${(avgConfidence * 100).toFixed(1)}%`);
+    }
+
+    if (avgLatency > 10_000) {
+      status = status === 'ok' ? 'degraded' : status;
+      warnings.push(`High average latency: ${avgLatency.toFixed(0)}ms`);
+    }
+
+    if (lowConfidenceRate > 0.3) {
+      warnings.push(`${(lowConfidenceRate * 100).toFixed(1)}% of calls below confidence threshold`);
+    }
+
+    // Per-model breakdown
+    const models: Record<string, ModelMetrics> = {};
+    const modelNames = [...new Set(recent.map(m => m.model))];
+    for (const model of modelNames) {
+      const modelCalls = recent.filter(m => m.model === model);
+      const modelSuccesses = modelCalls.filter(m => m.success);
+      const totalTokens = modelCalls.reduce((s, m) => s + (m.tokenUsage?.inputTokens ?? 0) + (m.tokenUsage?.outputTokens ?? 0), 0);
+
+      models[model] = {
+        calls: modelCalls.length,
+        successRate: modelSuccesses.length / modelCalls.length,
+        avgLatencyMs: modelCalls.reduce((s, m) => s + m.latencyMs, 0) / modelCalls.length,
+        avgConfidence: modelSuccesses.length > 0
+          ? modelSuccesses.reduce((s, m) => s + m.confidence, 0) / modelSuccesses.length
+          : 0,
+        totalTokens,
+      };
+    }
+
+    return {
+      status,
+      aiAvailable: errorRate < 1,
+      message: warnings.length > 0 ? warnings.join('; ') : 'All AI systems operating normally',
+      window: `${windowMs / 60_000}m`,
+      metrics: {
+        totalCalls: recent.length,
+        successRate: 1 - errorRate,
+        avgConfidence,
+        avgLatencyMs: avgLatency,
+        lowConfidenceRate,
+        errorRate,
+      },
+      models,
+    };
+  }
+
+  private emptyMetrics() {
+    return {
+      totalCalls: 0,
+      successRate: 1,
+      avgConfidence: 0,
+      avgLatencyMs: 0,
+      lowConfidenceRate: 0,
+      errorRate: 0,
+    };
+  }
+}
+
+// --- Types ---
+
+export interface AIHealthStatus {
+  status: 'ok' | 'degraded' | 'unhealthy';
+  aiAvailable: boolean;
+  message: string;
+  window: string;
+  metrics: {
+    totalCalls: number;
+    successRate: number;
+    avgConfidence: number;
+    avgLatencyMs: number;
+    lowConfidenceRate: number;
+    errorRate: number;
+  };
+  models: Record<string, ModelMetrics>;
+}
+
+interface ModelMetrics {
+  calls: number;
+  successRate: number;
+  avgLatencyMs: number;
+  avgConfidence: number;
+  totalTokens: number;
+}
+
+// --- Singleton ---
+
+export const aiHealthMetrics = new AIHealthMetrics();

package/templates/ai/guardrails-ts/src/lib/ai/index.ts.template

@@ -0,0 +1,17 @@
+/**
+ * AI Guardrails — {{PROJECT_NAME_PASCAL}}
+ *
+ * Central export for all AI safety infrastructure.
+ *
+ * Usage:
+ *   import { getAIClient } from '@/lib/ai';
+ *   const ai = getAIClient();
+ *   const result = await ai.generate({ prompt: '...', schema: MySchema });
+ *
+ * Compliance: EU AI Act (2024/1689), NIST AI RMF 1.0
+ */
+
+export { AIClient, getAIClient, type AIResponse, type AIClientConfig } from './client.js';
+export { validateInput, sanitizeInput, type InputValidationResult } from './input-guard.js';
+export { aiAuditLog, type AuditEntry, type AuditLogConfig } from './audit-log.js';
+export { aiHealthMetrics, type AIHealthStatus } from './health.js';

package/templates/ai/guardrails-ts/src/lib/ai/input-guard.ts.template

@@ -0,0 +1,124 @@
+/**
+ * AI Input Guard — Prompt injection detection and input sanitization.
+ *
+ * Compliance: EU AI Act Art. 15 (robustness), NIST AI RMF Manage 2.2
+ *
+ * Detects common prompt injection patterns before they reach the model.
+ * This is a defense-in-depth layer — the model itself has safety training,
+ * but catching obvious attacks early is cheaper and more auditable.
+ */
+
+export interface InputValidationResult {
+  blocked: boolean;
+  reason?: string;
+  /** Detected injection patterns (for audit logging) */
+  detectedPatterns?: string[];
+}
+
+// --- Injection Detection Patterns ---
+
+const INJECTION_PATTERNS: Array<{ pattern: RegExp; name: string }> = [
+  // Direct instruction override attempts
+  { pattern: /ignore\s+(all\s+)?(previous|prior|above)\s+(instructions|prompts|rules)/i, name: 'instruction-override' },
+  { pattern: /disregard\s+(all\s+)?(previous|prior|above|your)\s+(instructions|prompts|rules|training)/i, name: 'instruction-override' },
+  { pattern: /forget\s+(all\s+)?(previous|prior|your)\s+(instructions|context|rules)/i, name: 'instruction-override' },
+
+  // Role manipulation
+  { pattern: /you\s+are\s+now\s+(a|an|the)\s+/i, name: 'role-manipulation' },
+  { pattern: /act\s+as\s+(if\s+you\s+are|a|an)\s+/i, name: 'role-manipulation' },
+  { pattern: /pretend\s+(to\s+be|you\s+are)\s+/i, name: 'role-manipulation' },
+  { pattern: /from\s+now\s+on\s+(you|your)\s+/i, name: 'role-manipulation' },
+
+  // System prompt extraction
+  { pattern: /what\s+(is|are)\s+your\s+(system\s+)?(prompt|instructions|rules)/i, name: 'prompt-extraction' },
+  { pattern: /show\s+me\s+your\s+(system\s+)?(prompt|instructions)/i, name: 'prompt-extraction' },
+  { pattern: /repeat\s+(your|the)\s+(system\s+)?(prompt|instructions)/i, name: 'prompt-extraction' },
+  { pattern: /print\s+(your|the)\s+(system\s+)?(prompt|instructions)/i, name: 'prompt-extraction' },
+
+  // Delimiter injection
+  { pattern: /\<\/?system\>/i, name: 'delimiter-injection' },
+  { pattern: /\[INST\]/i, name: 'delimiter-injection' },
+  { pattern: /\<\|im_start\|/i, name: 'delimiter-injection' },
+  { pattern: /###\s*(system|instruction|human|assistant)/i, name: 'delimiter-injection' },
+
+  // Data exfiltration
+  { pattern: /send\s+(this|the|all)\s+(data|info|conversation)\s+to/i, name: 'data-exfiltration' },
+  { pattern: /forward\s+(this|everything)\s+to/i, name: 'data-exfiltration' },
+];
+
+// --- Suspicious content patterns ---
+
+const SUSPICIOUS_PATTERNS: Array<{ pattern: RegExp; name: string }> = [
+  // Encoded payloads
+  { pattern: /eval\s*\(/i, name: 'code-execution' },
+  { pattern: /exec\s*\(/i, name: 'code-execution' },
+  { pattern: /import\s+(?:os|subprocess)|subprocess\./i, name: 'code-execution' },
+
+  // Base64 encoded content (potential hidden instructions)
+  { pattern: /[A-Za-z0-9+/]{100,}={0,2}/i, name: 'encoded-payload' },
+];
+
+/**
+ * Validate input for prompt injection and other safety concerns.
+ *
+ * Returns blocked: true if injection detected, with details for audit logging.
+ * Returns blocked: false if input is clean.
+ */
+export function validateInput(input: string): InputValidationResult {
+  // Normalize Unicode to defeat homoglyph attacks (e.g., Cyrillic "а" for Latin "a")
+  const normalized = input.normalize('NFKC');
+  const detectedPatterns: string[] = [];
+
+  // Check injection patterns (always block)
+  for (const { pattern, name } of INJECTION_PATTERNS) {
+    if (pattern.test(normalized)) {
+      detectedPatterns.push(name);
+    }
+  }
+
+  if (detectedPatterns.length > 0) {
+    return {
+      blocked: true,
+      reason: `Potential prompt injection detected: ${[...new Set(detectedPatterns)].join(', ')}`,
+      detectedPatterns,
+    };
+  }
+
+  // Check suspicious patterns (warn but don't block by default)
+  const suspicious: string[] = [];
+  for (const { pattern, name } of SUSPICIOUS_PATTERNS) {
+    if (pattern.test(normalized)) {
+      suspicious.push(name);
+    }
+  }
+
+  if (suspicious.length > 0) {
+    return {
+      blocked: false,
+      reason: `Suspicious patterns detected (not blocked): ${suspicious.join(', ')}`,
+      detectedPatterns: suspicious,
+    };
+  }
+
+  return { blocked: false };
+}
+
+/**
+ * Sanitize input by removing known dangerous patterns.
+ * Use this when you want to clean input rather than reject it.
+ */
+export function sanitizeInput(input: string): string {
+  let sanitized = input;
+
+  // Remove system/instruction delimiters
+  sanitized = sanitized.replace(/<\/?system>/gi, '');
+  sanitized = sanitized.replace(/\[INST\]/gi, '');
+  sanitized = sanitized.replace(/<\|im_start\|[^>]*>?/gi, '');
+  sanitized = sanitized.replace(/<\|im_end\|>?/gi, '');
+  sanitized = sanitized.replace(/###\s*(system|instruction|human|assistant)/gi, '');
+
+  // Remove null bytes
+  sanitized = sanitized.replace(/\0/g, '');
+
+  return sanitized;
+}

package/templates/auth/nextauth/src/lib/auth.ts.template

@@ -10,16 +10,21 @@ export const { handlers, signIn, signOut, auth } = NextAuth({
         password: { label: 'Password', type: 'password' },
       },
       async authorize(credentials) {
-        // TODO: Implement actual authentication logic
-        // Replace with database lookup and password verification
+        // IMPORTANT: This is a placeholder. Replace this with your actual
+        // authentication logic (database lookup + password hash comparison)
+        // before going live. Returning null here means all logins are
+        // rejected until you wire up real verification.
         if (!credentials?.email || !credentials?.password) {
           return null;
         }
-        return {
-          id: '1',
-          email: credentials.email as string,
-          name: 'User',
-        };
+
+        // Uncomment and modify once your user table is ready:
+        // const user = await db.user.findUnique({ where: { email: credentials.email } });
+        // if (user && await bcrypt.compare(credentials.password, user.passwordHash)) {
+        //   return { id: user.id, email: user.email, name: user.name };
+        // }
+
+        return null;
       },
     }),
   ],

package/templates/backend/express/Dockerfile.template

@@ -0,0 +1,18 @@
+FROM node:22-alpine AS builder
+
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+FROM node:22-alpine
+WORKDIR /app
+RUN addgroup -g 1001 -S nodejs && adduser -S nodejs -u 1001
+COPY package*.json ./
+RUN npm ci --omit=dev
+COPY --from=builder /app/dist ./dist
+RUN chown -R nodejs:nodejs /app
+USER nodejs
+EXPOSE 3001
+CMD ["node", "dist/index.js"]

package/templates/backend/express/package.json.template

@@ -0,0 +1,33 @@
+{
+  "name": "{{PROJECT_NAME}}-server",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "db:push": "prisma db push",
+    "db:studio": "prisma studio",
+    "db:generate": "prisma generate"
+  },
+  "dependencies": {
+    "express": "^5.1.0",
+    "cors": "^2.8.5",
+    "@prisma/client": "^6.6.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3",
+    "@types/node": "^22.14.0",
+    "@types/express": "^5.0.0",
+    "@types/cors": "^2.8.17",
+    "tsx": "^4.19.0",
+    "eslint": "^9.25.0",
+    "prisma": "^6.6.0",
+    "vitest": "^3.1.1"
+  }
+}

package/templates/backend/express/src/index.ts.template

@@ -0,0 +1,34 @@
+import express from 'express';
+import cors from 'cors';
+import { healthRouter } from './routes/health.js';
+
+const app = express();
+const PORT = Number(process.env.PORT) || 3001;
+
+app.use(cors({ origin: process.env.ALLOWED_ORIGINS?.split(',') || ['http://localhost:3000'] }));
+app.use(express.json());
+
+app.use(healthRouter);
+
+// Global error handler — never leak stack traces
+app.use((err: Error, _req: express.Request, res: express.Response, next: express.NextFunction) => {
+  console.error('Unhandled error:', err);
+  if (res.headersSent) {
+    return next(err);
+  }
+  res.status(500).json({ error: { code: 'INTERNAL_ERROR', message: 'An unexpected error occurred' } });
+});
+
+const server = app.listen(PORT, () => {
+  console.log(`{{PROJECT_NAME_PASCAL}} server listening on port ${PORT}`);
+});
+
+// Graceful shutdown
+function shutdown() {
+  console.log('Shutting down gracefully...');
+  server.close(() => process.exit(0));
+  setTimeout(() => process.exit(1), 10_000);
+}
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);

package/templates/backend/express/src/routes/health.ts.template

@@ -0,0 +1,27 @@
+import { Router } from 'express';
+
+export const healthRouter = Router();
+
+// Liveness probe — always returns ok if the process is running
+healthRouter.get('/health', (_req, res) => {
+  res.json({
+    status: 'ok',
+    timestamp: new Date().toISOString(),
+    uptime: process.uptime(),
+    service: '{{PROJECT_NAME}}',
+  });
+});
+
+// Readiness probe — add real dependency checks (database, cache, etc.)
+// before using this as a Kubernetes readiness probe
+healthRouter.get('/healthz', async (_req, res) => {
+  // TODO: Replace with actual checks, e.g.:
+  //   const db = await prisma.$queryRaw`SELECT 1`;
+  const checks: Record<string, string> = {};
+
+  res.json({
+    status: 'ok',
+    service: '{{PROJECT_NAME}}',
+    checks,
+  });
+});

package/templates/backend/express/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/templates/backend/fastapi/backend/Dockerfile.template

@@ -2,11 +2,16 @@ FROM python:3.11-slim
 
 WORKDIR /app
 
+RUN groupadd -r appuser && useradd -r -g appuser appuser
+
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
 COPY . .
 
+RUN chown -R appuser:appuser /app
+USER appuser
+
 EXPOSE 8000
 
 CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

package/templates/backend/fastapi/backend/app/api/health.py.template

@@ -16,7 +16,7 @@ async def health_check():
 
 @router.get("/healthz")
 async def health_check_deep():
-    """Deep health check — verifies database connectivity."""
+    """Deep health check. Verifies database connectivity."""
     try:
         async with async_session() as session:
             await session.execute(text("SELECT 1"))

package/templates/backend/fastapi/backend/app/core/config.py.template

@@ -6,7 +6,7 @@ class Settings(BaseSettings):
     app_name: str = "{{PROJECT_NAME_PASCAL}}"
     debug: bool = False
 
-    # Database — no default: must be set via .env or environment
+    # Database (no default: must be set via .env or environment)
     database_url: str
 
     # CORS

package/templates/backend/fastapi/backend/app/core/errors.py

@@ -1,5 +1,5 @@
 class AppError(Exception):
-    """Structured application error — never leaks stack traces to clients."""
+    """Structured application error. Never leaks stack traces to clients."""
 
     def __init__(
         self,

package/templates/backend/fastapi/backend/app/main.py.template

@@ -4,6 +4,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 
 from app.api.health import router as health_router
+from app.portal.router import router as portal_router
 from app.core.config import settings
 from app.core.errors import AppError
 
@@ -36,9 +37,10 @@ app.add_middleware(
 
 # Routes
 app.include_router(health_router, tags=["health"])
+app.include_router(portal_router)
 
 
-# Global exception handler — never leak stack traces
+# Global exception handler - never leak stack traces
 @app.exception_handler(AppError)
 async def app_error_handler(request: Request, exc: AppError):
     return JSONResponse(

package/templates/backend/fastapi/backend/requirements.txt.template

@@ -10,5 +10,7 @@ passlib[bcrypt]>=1.7.4
 httpx>=0.28.0
 pytest>=8.3.0
 pytest-asyncio>=0.25.0
+markdown>=3.7
+bleach>=6.2.0
 ruff>=0.11.0
 pyright>=1.1.400

package/templates/backend/hono/Dockerfile.template

@@ -0,0 +1,18 @@
+FROM node:22-alpine AS builder
+
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+FROM node:22-alpine
+WORKDIR /app
+RUN addgroup -g 1001 -S nodejs && adduser -S nodejs -u 1001
+COPY package*.json ./
+RUN npm ci --omit=dev
+COPY --from=builder /app/dist ./dist
+RUN chown -R nodejs:nodejs /app
+USER nodejs
+EXPOSE 3000
+CMD ["node", "dist/index.js"]

package/templates/backend/hono/package.json.template

@@ -0,0 +1,31 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "db:push": "prisma db push",
+    "db:studio": "prisma studio",
+    "db:generate": "prisma generate"
+  },
+  "dependencies": {
+    "hono": "^4.7.0",
+    "@hono/node-server": "^1.14.0",
+    "@prisma/client": "^6.6.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3",
+    "@types/node": "^22.14.0",
+    "tsx": "^4.19.0",
+    "eslint": "^9.25.0",
+    "prisma": "^6.6.0",
+    "vitest": "^3.1.1"
+  }
+}

package/templates/backend/hono/src/index.ts.template

@@ -0,0 +1,32 @@
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { serve } from '@hono/node-server';
+import { healthRoutes } from './routes/health.js';
+
+const app = new Hono();
+
+app.use('*', cors());
+
+app.route('/', healthRoutes);
+
+// Global error handler — never leak stack traces
+app.onError((err, c) => {
+  console.error('Unhandled error:', err);
+  return c.json({ error: { code: 'INTERNAL_ERROR', message: 'An unexpected error occurred' } }, 500);
+});
+
+const PORT = Number(process.env.PORT) || 3000;
+
+const server = serve({ fetch: app.fetch, port: PORT }, () => {
+  console.log(`{{PROJECT_NAME_PASCAL}} server listening on port ${PORT}`);
+});
+
+// Graceful shutdown
+function shutdown() {
+  console.log('Shutting down gracefully...');
+  server.close(() => process.exit(0));
+  setTimeout(() => process.exit(1), 10_000);
+}
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);

package/templates/backend/hono/src/routes/health.ts.template

@@ -0,0 +1,27 @@
+import { Hono } from 'hono';
+
+export const healthRoutes = new Hono();
+
+// Liveness probe — always returns ok if the process is running
+healthRoutes.get('/health', (c) => {
+  return c.json({
+    status: 'ok',
+    timestamp: new Date().toISOString(),
+    uptime: process.uptime(),
+    service: '{{PROJECT_NAME}}',
+  });
+});
+
+// Readiness probe — add real dependency checks (database, cache, etc.)
+// before using this as a Kubernetes readiness probe
+healthRoutes.get('/healthz', async (c) => {
+  // TODO: Replace with actual checks, e.g.:
+  //   const db = await prisma.$queryRaw`SELECT 1`;
+  const checks: Record<string, string> = {};
+
+  return c.json({
+    status: 'ok',
+    service: '{{PROJECT_NAME}}',
+    checks,
+  });
+});

package/templates/backend/hono/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "isolatedModules": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}