@shahmilsaari/memory-core 0.2.10 → 0.2.12

package/README.md

@@ -518,7 +518,7 @@ Pick the one that matches how your project is structured.
 | Modular Monolith | You're building feature modules that might become microservices later |
 | MVC | Standard web app with controllers and services |
 | Hexagonal | You want ports and adapters for maximum testability |
-| Next.js | Next.js 13+ with server components and server actions |
+| Go REST API | Go backend API with idiomatic error handling and clean package structure |
 | Laravel | Laravel with service-repository pattern |
 | NestJS | Modules, guards, pipes, DTOs, repository pattern |
 

package/dist/cli.js

@@ -332,30 +332,34 @@ var seeds = [
   { type: "rule", scope: "global", architecture: "hexagonal", title: "Port naming convention", content: "Name ports as I + [Action] + [Resource]: ICreateUser, IFindOrderById, ISendEmail. Adapters use the technology name: PostgresCreateUser, StripeCharge.", tags: ["naming", "ports", "hexagonal"] },
   { type: "decision", scope: "global", architecture: "hexagonal", title: "Test core without infrastructure", content: "Core unit tests run in milliseconds with no DB or network. Integration tests add adapters one at a time. E2E tests use real infrastructure.", tags: ["testing", "hexagonal"] },
   // ══════════════════════════════════════════════════════════════════════════
-  // NEXT.JS APP ROUTER
+  // GO REST API
   // ══════════════════════════════════════════════════════════════════════════
-  // ── Rendering Strategy ───────────────────────────────────────────────────
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Server Components by default", content: 'Every component is a Server Component unless it requires interactivity (onClick, useState, useEffect). Add "use client" only when necessary, as low in the tree as possible.', tags: ["server-components", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Fetch in Server Components", content: "Fetch data directly in async Server Components. Never use useEffect, SWR, or React Query for initial server-side data. Client-side fetching is for user-triggered updates only.", tags: ["data-fetching", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Server Actions for mutations", content: "All form submissions and data mutations use Server Actions. API routes are only for third-party webhooks or browser clients that cannot use Server Actions.", tags: ["server-actions", "mutations", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Static by default, dynamic when needed", content: 'Pages are statically rendered unless they use cookies(), headers(), or searchParams. Opt into dynamic rendering explicitly with export const dynamic = "force-dynamic".', tags: ["rendering", "performance", "nextjs"] },
-  { type: "pattern", scope: "global", architecture: "nextjs", title: "Suspense boundaries for streaming", content: "Wrap slow data-fetching sections in <Suspense fallback={<Skeleton />}>. This enables streaming and progressive hydration. Do not block the entire page on one slow query.", tags: ["suspense", "streaming", "nextjs"] },
-  { type: "pattern", scope: "global", architecture: "nextjs", title: "Parallel data fetching", content: "Use Promise.all() for independent data fetches in the same Server Component. Sequential awaits in a single component waterfall unnecessarily.", tags: ["performance", "data-fetching", "nextjs"] },
-  // ── Structure ─────────────────────────────────────────────────────────────
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Thin page.tsx files", content: "page.tsx fetches data and passes it to a feature component. No JSX logic, no conditionals, no business logic in page files.", tags: ["structure", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Colocate by route", content: "Components used only by one route live next to that route. Components used across 3+ routes move to src/components/. Utils used across routes go to src/lib/.", tags: ["structure", "colocation", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Route groups for organization", content: "Use (groupName) folders to organize routes without affecting URLs. Group by concern: (marketing), (dashboard), (auth). Each group can have its own layout.", tags: ["route-groups", "structure", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "loading.tsx and error.tsx always", content: "Every dynamic route segment must have a loading.tsx (Suspense fallback) and error.tsx (error boundary). Never let routes fail or hang without user feedback.", tags: ["loading", "error-handling", "nextjs"] },
-  // ── Security & Config ────────────────────────────────────────────────────
-  { type: "rule", scope: "global", architecture: "nextjs", title: "No secrets in NEXT_PUBLIC_", content: "NEXT_PUBLIC_ variables are embedded in the client bundle. Never put API keys, tokens, or DB credentials there. Server-only secrets stay in Server Components and Actions.", tags: ["security", "env", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Auth in middleware.ts", content: "Route protection and session validation happens in middleware.ts at the edge. Never rely on page-level checks as the only auth guard.", tags: ["auth", "middleware", "security", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Validate Server Action inputs", content: "Always validate and sanitize inputs inside Server Actions using zod or similar. Server Actions are public endpoints \u2014 treat them like API routes.", tags: ["validation", "server-actions", "security", "nextjs"] },
-  // ── Performance ──────────────────────────────────────────────────────────
-  { type: "rule", scope: "global", architecture: "nextjs", title: "next/image for all images", content: "Use next/image for all images. It provides automatic WebP conversion, lazy loading, and size optimization. Never use raw <img> tags.", tags: ["performance", "images", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "next/font for typography", content: "Use next/font for fonts. It eliminates layout shift, self-hosts, and applies font-display: swap automatically. Never load fonts from Google Fonts CDN directly.", tags: ["performance", "fonts", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Cache fetch calls with tags", content: 'Tag fetch() calls with cache tags: fetch(url, { next: { tags: ["products"] } }). Revalidate by tag on mutation with revalidateTag("products").', tags: ["caching", "performance", "nextjs"] },
-  { type: "pattern", scope: "global", architecture: "nextjs", title: "ISR for semi-static pages", content: "Use Incremental Static Regeneration for pages that change infrequently: export const revalidate = 3600. Combine with revalidatePath() on writes.", tags: ["isr", "performance", "nextjs"] },
-  { type: "rule", scope: "global", architecture: "nextjs", title: "Metadata API for SEO", content: "Define page metadata using the Metadata API (export const metadata) or generateMetadata(). Never use next/head or raw <Head> in App Router.", tags: ["seo", "metadata", "nextjs"] },
+  // ── Package Structure ────────────────────────────────────────────────────
+  { type: "rule", scope: "global", architecture: "go-api", title: "cmd/internal/pkg layout", content: "Organize code into cmd/ (main packages), internal/ (private app code), pkg/ (reusable public packages). cmd/api/main.go is the only entry point. Never put business logic in main.go.", tags: ["structure", "packages", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Thin HTTP handlers", content: "Handlers parse the request, call a service method, and write the response. No business logic, no DB calls, no conditional branching beyond input validation in handlers.", tags: ["handler", "structure", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Service layer owns business logic", content: "Services accept and return domain types, not http.Request or http.ResponseWriter. Services are fully testable without starting an HTTP server.", tags: ["service", "business-logic", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Repository layer for data access", content: "All database calls live in a repository layer. Services depend on repository interfaces, never on database drivers (database/sql, pgx, gorm) directly.", tags: ["repository", "database", "go"] },
+  // ── Error Handling ───────────────────────────────────────────────────────
+  { type: "rule", scope: "global", architecture: "go-api", title: "Always return errors explicitly", content: "Return errors as the last return value. Never use panic in library, service, or handler code. Reserve panic only for unrecoverable failures at startup (e.g., missing config).", tags: ["error-handling", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Wrap errors with context", content: 'Wrap errors at each layer boundary: fmt.Errorf("createUser: %w", err). This preserves the original error for errors.Is/errors.As and adds context to stack traces.', tags: ["error-handling", "wrapping", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Never ignore returned errors", content: "Every returned error must be handled or explicitly discarded with a comment. Silently assigning to _ hides bugs. Lint with errcheck to enforce this.", tags: ["error-handling", "go"] },
+  { type: "pattern", scope: "global", architecture: "go-api", title: "Sentinel errors for known cases", content: 'Define sentinel errors (var ErrNotFound = errors.New("not found")) for expected failure cases. Callers use errors.Is() to check. Never compare error strings.', tags: ["error-handling", "sentinel", "go"] },
+  // ── Interfaces & Types ───────────────────────────────────────────────────
+  { type: "rule", scope: "global", architecture: "go-api", title: "Small interfaces at the point of use", content: "Define interfaces where they are consumed, not where implementations live. Prefer single-method interfaces. A 10-method interface is a sign the consumer needs too much.", tags: ["interfaces", "design", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Request/response structs for all handlers", content: "Define explicit request and response structs for every handler. Never bind directly to domain models. This decouples API shape from internal representation.", tags: ["dto", "handler", "go"] },
+  // ── Context & Concurrency ────────────────────────────────────────────────
+  { type: "rule", scope: "global", architecture: "go-api", title: "context.Context as first parameter", content: "Every function that may block, make a network call, or query a database accepts context.Context as its first parameter. Never store Context in a struct.", tags: ["context", "concurrency", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Graceful shutdown", content: "Catch SIGINT and SIGTERM via signal.NotifyContext. Call server.Shutdown(ctx) to drain in-flight requests before exiting. Never call os.Exit(1) directly in the server loop.", tags: ["shutdown", "reliability", "go"] },
+  // ── Configuration & Logging ──────────────────────────────────────────────
+  { type: "rule", scope: "global", architecture: "go-api", title: "Config struct loaded at startup", content: "Read all configuration from environment variables into a validated Config struct in main.go before starting the server. Fail fast on missing required values. Never read env vars inside handlers or services.", tags: ["config", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Structured logging only", content: "Use slog (stdlib) or zerolog for all logging. Log with key-value fields, not format strings. Never use fmt.Println or log.Printf in production paths.", tags: ["logging", "observability", "go"] },
+  // ── Testing ──────────────────────────────────────────────────────────────
+  { type: "rule", scope: "global", architecture: "go-api", title: "Table-driven tests", content: "Write unit tests as table-driven tests using t.Run(). Each test case has a name, input, and expected output. This keeps tests readable and easy to extend.", tags: ["testing", "go"] },
+  { type: "pattern", scope: "global", architecture: "go-api", title: "Test handlers with httptest", content: "Test HTTP handlers using httptest.NewRecorder() and httptest.NewRequest(). Never spin up a real server in unit tests.", tags: ["testing", "handler", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Mock with interfaces, not libraries", content: "Inject mock implementations via interfaces rather than using reflection-based mock libraries. Write mocks by hand or use mockery \u2014 keep them simple.", tags: ["testing", "mocking", "go"] },
+  // ── Middleware & Security ────────────────────────────────────────────────
+  { type: "rule", scope: "global", architecture: "go-api", title: "Middleware registered at router level", content: "Register all middleware (auth, logging, CORS, recovery) at the router, not inside individual handlers. Middleware wraps the handler chain \u2014 it should never be called manually.", tags: ["middleware", "structure", "go"] },
+  { type: "rule", scope: "global", architecture: "go-api", title: "Validate all incoming data", content: "Validate and sanitize all request inputs before passing to the service layer. Return 400 Bad Request with a structured error body for invalid input. Never trust client data.", tags: ["validation", "security", "go"] },
   // ══════════════════════════════════════════════════════════════════════════
   // LARAVEL SERVICE REPOSITORY
   // ══════════════════════════════════════════════════════════════════════════
@@ -568,9 +572,6 @@ function detectProject(cwd = process.cwd()) {
       return {};
     }
   };
-  if (has("next.config.js") || has("next.config.ts") || has("next.config.mjs")) {
-    return { language: "TypeScript", framework: "Next.js" };
-  }
   if (has("artisan") && has("composer.json")) {
     return { language: "PHP", framework: "Laravel" };
   }
@@ -1697,7 +1698,7 @@ program.command("init").description("Initialize memory-core in the current proje
     message: "Project name?",
     default: process.cwd().split("/").pop() ?? "my-project"
   });
-  const inferredProjectType = ["Next.js", "Nuxt.js"].includes(detected.framework) ? "fullstack" : ["React", "Vue.js", "Svelte"].includes(detected.framework) ? "frontend" : "backend";
+  const inferredProjectType = ["Nuxt.js"].includes(detected.framework) ? "fullstack" : ["React", "Vue.js", "Svelte"].includes(detected.framework) ? "frontend" : "backend";
   const projectType = quick ? inferredProjectType : await select({
     message: "Project type?",
     choices: [
@@ -1709,7 +1710,7 @@ program.command("init").description("Initialize memory-core in the current proje
   let backendArchitecture;
   if (projectType === "backend" || projectType === "fullstack") {
     if (quick) {
-      backendArchitecture = detected.framework === "NestJS" ? "nestjs" : detected.framework === "Laravel" ? "laravel-service-repository" : "clean-architecture";
+      backendArchitecture = detected.framework === "NestJS" ? "nestjs" : detected.framework === "Laravel" ? "laravel-service-repository" : detected.framework === "Go" ? "go-api" : "clean-architecture";
     } else {
       const backendProfiles = listProfiles("backend");
       backendArchitecture = await select({
@@ -1725,7 +1726,6 @@ program.command("init").description("Initialize memory-core in the current proje
   if (projectType === "frontend" || projectType === "fullstack") {
     if (quick) {
       const frameworkMap = {
-        "Next.js": "nextjs",
         "Nuxt.js": "nuxt",
         React: "react",
         "Vue.js": "vue",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shahmilsaari/memory-core",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "Universal AI memory core — generate AI context files from architecture profiles with RAG support",
   "type": "module",
   "bin": {

package/profiles/go-api.yml

@@ -0,0 +1,43 @@
+name: go-api
+displayName: Go REST API
+layer: backend
+description: Go REST API with clean package structure, idiomatic error handling, and testability
+
+rules:
+  - Organize code into cmd/, internal/, and pkg/ — cmd/ holds main packages, internal/ holds private packages, pkg/ holds public packages
+  - HTTP handlers are thin — parse request, call service, write response. No business logic.
+  - Services own all business logic — they accept and return domain types, not HTTP types
+  - Always pass context.Context as the first parameter for cancellation and deadline propagation
+  - Return errors explicitly — never panic in library or service code. Reserve panic only for unrecoverable startup failures.
+  - Wrap errors at each layer boundary using fmt.Errorf with the %w verb — this chains errors so errors.Is and errors.As work across layers
+  - Define small, single-method interfaces at the point of use, not at the point of implementation
+  - Use struct-based request/response types for all handler inputs and outputs
+  - Validate all incoming request data before passing to the service layer
+  - Configuration comes from environment variables — use a dedicated Config struct loaded at startup with validation
+  - Use structured logging (slog or zerolog) — never log with fmt.Println in production code
+  - Implement graceful shutdown — catch SIGINT/SIGTERM and drain in-flight requests before exiting
+  - Use table-driven tests with t.Run() for all unit tests
+  - Register middleware at the router level — never call middleware logic inside handlers
+  - Database calls live in a repository layer — services never import database drivers directly
+
+folders:
+  - cmd/api/
+  - cmd/api/main.go
+  - internal/handler/
+  - internal/service/
+  - internal/repository/
+  - internal/domain/
+  - internal/middleware/
+  - internal/config/
+  - pkg/
+  - api/
+
+avoid:
+  - Global mutable state outside of the DI wiring in main.go
+  - Business logic inside HTTP handlers
+  - Direct database calls in service layer
+  - Ignoring returned errors (assign to _ only when truly safe)
+  - Naked returns in functions longer than a few lines
+  - Using init() for configuration — use explicit constructors instead
+  - Panicking in non-main code
+  - Mixing HTTP concerns with domain logic

package/profiles/nextjs.yml

@@ -1,32 +0,0 @@
-name: nextjs
-displayName: Next.js App Router
-layer: fullstack
-description: Next.js 13+ App Router with server components, server actions, and colocation
-
-rules:
-  - Use Server Components by default — add 'use client' only when interactivity is required
-  - Data fetching happens in Server Components, not client hooks
-  - Use Server Actions for form mutations and data writes
-  - Keep page.tsx files thin — delegate to feature components
-  - Colocate components, hooks, and utilities near the route that uses them
-  - Shared UI lives in src/components/, shared logic in src/lib/
-  - API routes are for external integrations only — prefer Server Actions for internal mutations
-  - Use Route Groups to organize without affecting URL structure
-  - Environment variables exposed to client must be prefixed NEXT_PUBLIC_
-
-folders:
-  - app/(routes)
-  - app/api
-  - src/components/ui
-  - src/components/features
-  - src/lib/utils
-  - src/lib/actions
-  - src/lib/db
-  - src/types
-
-avoid:
-  - Data fetching in Client Components (use Server Components instead)
-  - useEffect for data loading
-  - Business logic inside page.tsx
-  - Mixing server and client code in the same file
-  - Exposing secrets via NEXT_PUBLIC_ variables