loki-mode 6.60.0 → 6.62.0

package/templates/npm-library.md

@@ -34,6 +34,48 @@ A well-structured npm package with TypeScript support, comprehensive documentati
 - TypeScript declarations compile cleanly in consuming projects
 - Documentation generated without warnings
 
+## Project Structure
+```
+/
+├── src/
+│   ├── index.ts               # Public API exports
+│   ├── string/
+│   │   └── index.ts           # String utility functions
+│   ├── array/
+│   │   └── index.ts           # Array utility functions
+│   ├── object/
+│   │   └── index.ts           # Object utility functions
+│   └── types.ts               # Shared TypeScript types
+├── tests/
+│   ├── string.test.ts         # String utility tests
+│   ├── array.test.ts          # Array utility tests
+│   └── object.test.ts         # Object utility tests
+├── docs/                      # Auto-generated API docs (typedoc)
+├── .changeset/                # Changeset version management
+├── tsconfig.json
+├── tsup.config.ts             # Build config (ESM + CJS)
+├── vitest.config.ts           # Test config with coverage
+├── package.json               # exports map, sideEffects: false
+└── README.md
+```
+
+## Out of Scope
+- Runtime dependencies (library must be zero-dep)
+- Framework-specific integrations (React hooks, Vue composables)
+- Polyfills for legacy environments (ES2020+ baseline)
+- Monorepo or workspace setup
+- Documentation website hosting
+- npm org or scoped package configuration
+- Benchmarking suite
+
+## Acceptance Criteria
+- `npm pack` produces a tarball with both ESM and CJS builds
+- Importing the package in a TypeScript project shows correct type hints
+- Tree shaking eliminates unused exports in a Rollup/webpack build
+- `npm run docs` generates API documentation without warnings
+- `npm run test` passes with 90%+ line coverage
+- `npx changeset version` bumps version and updates changelog
+
 ## Success Metrics
 - Package installs and imports correctly in ESM and CJS projects
 - All public functions have TSDoc comments and generated docs

package/templates/rest-api.md

@@ -1,43 +1,180 @@
-# PRD: REST API Service
+# PRD: REST API Service (No Auth)
 
 ## Overview
-A production-ready RESTful API backend with authentication, CRUD operations, pagination, filtering, rate limiting, and comprehensive documentation.
+A production-ready RESTful API backend with CRUD operations, pagination, filtering, input validation, and auto-generated documentation. This template focuses on API design fundamentals without authentication complexity. For JWT auth, see `rest-api-auth.md`.
 
 ## Target Users
 - Backend developers building API-first applications
 - Teams needing a structured API for frontend or mobile clients
 - Developers learning REST API best practices
 
-## Core Features
-1. **Authentication** - JWT-based auth with access and refresh tokens, password hashing with bcrypt
-2. **Resource CRUD** - Full create, read, update, delete operations with proper HTTP methods and status codes
-3. **Pagination and Filtering** - Cursor-based pagination, field filtering, sorting, and search across resources
-4. **Rate Limiting** - Per-endpoint and per-user rate limits with configurable windows and limits
-5. **Input Validation** - Request body and query parameter validation with detailed error messages
-6. **API Documentation** - Auto-generated OpenAPI/Swagger documentation with interactive testing
-7. **Error Handling** - Consistent error response format with appropriate HTTP status codes
-
-## Technical Requirements
-- Node.js with Express and TypeScript
-- Prisma ORM with SQLite (dev) / PostgreSQL (prod)
-- JSON Web Tokens for stateless authentication
-- Express middleware architecture
-- Environment-based configuration
-- Structured logging with request correlation IDs
-- Database migrations and seed data
-
-## Quality Gates
-- Unit tests for middleware, validators, and business logic
-- Integration tests for all API endpoints
-- Authentication flow tested end-to-end
-- Rate limiter tested under concurrent requests
-- OpenAPI spec validates against schema
-- No N+1 query issues in list endpoints
-
-## Success Metrics
+## Features
+
+### MVP Features
+1. **Resource CRUD** - Full create, read, update, delete operations with proper HTTP methods and status codes
+2. **Pagination and Filtering** - Cursor-based pagination, field filtering, sorting, and search across resources
+3. **Input Validation** - Request body and query parameter validation with detailed error messages
+4. **API Documentation** - Auto-generated OpenAPI/Swagger documentation with interactive testing
+5. **Error Handling** - Consistent error response format with appropriate HTTP status codes
+6. **Structured Logging** - JSON-formatted request logs with correlation IDs
+7. **CORS Configuration** - Configurable allowed origins, methods, and headers
+
+### User Flow
+1. Client sends request to a resource endpoint (e.g., GET /api/posts)
+2. Server validates query params (pagination, filters, sort)
+3. Server queries database with applied filters and pagination
+4. Response returns data with pagination metadata (next cursor, total count)
+5. Swagger UI available at /docs for interactive API exploration
+
+## Tech Stack
+- Runtime: Node.js 20+
+- Framework: Express.js with TypeScript
+- Database: SQLite (dev) / PostgreSQL (prod) via Prisma ORM
+- Validation: zod
+- Documentation: swagger-jsdoc + swagger-ui-express
+- Testing: Vitest + supertest
+
+## Project Structure
+```
+/
+├── src/
+│   ├── app.ts                  # Express app setup, middleware
+│   ├── server.ts               # Entry point
+│   ├── config/
+│   │   └── index.ts            # Environment config with validation
+│   ├── middleware/
+│   │   ├── validate.ts         # Request validation middleware
+│   │   ├── errorHandler.ts     # Global error handler
+│   │   └── requestLogger.ts    # Structured logging middleware
+│   ├── routes/
+│   │   ├── posts.ts            # Post resource routes
+│   │   └── health.ts           # Health check route
+│   ├── controllers/
+│   │   └── postController.ts   # Post business logic
+│   ├── services/
+│   │   └── postService.ts      # Data access layer
+│   └── utils/
+│       ├── pagination.ts       # Cursor-based pagination helpers
+│       └── errors.ts           # Custom error classes
+├── prisma/
+│   ├── schema.prisma           # Database schema
+│   └── seed.ts                 # Seed data
+├── tests/
+│   ├── posts.test.ts           # Post endpoint tests
+│   ├── pagination.test.ts      # Pagination logic tests
+│   └── validation.test.ts      # Validation tests
+├── .env.example                # Environment variable template
+├── package.json
+└── README.md
+```
+
+## Database Schema
+
+```sql
+CREATE TABLE posts (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    title       VARCHAR(200) NOT NULL,
+    body        TEXT NOT NULL,
+    slug        VARCHAR(200) UNIQUE NOT NULL,
+    status      VARCHAR(20) DEFAULT 'draft' CHECK (status IN ('draft', 'published', 'archived')),
+    tags        TEXT,  -- JSON array of strings
+    created_at  TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at  TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX idx_posts_status ON posts(status);
+CREATE INDEX idx_posts_created_at ON posts(created_at);
+```
+
+## API Endpoints
+
+### Posts
+
+#### POST /api/posts
+- Body: `{ title, body, tags?, status? }`
+- Response: `201 { id, title, body, slug, status, tags, createdAt, updatedAt }`
+- Error: `400` validation
+
+#### GET /api/posts
+- Query: `?cursor=&limit=20&status=published&search=keyword&sort=createdAt&order=desc`
+- Response: `200 { data: [...], pagination: { nextCursor, hasMore, total } }`
+
+#### GET /api/posts/:id
+- Response: `200 { id, title, body, slug, status, tags, createdAt, updatedAt }`
+- Error: `404` not found
+
+#### PATCH /api/posts/:id
+- Body: `{ title?, body?, tags?, status? }`
+- Response: `200 { id, title, body, slug, status, tags, createdAt, updatedAt }`
+- Error: `404` not found, `400` validation
+
+#### DELETE /api/posts/:id
+- Response: `204` no content
+- Error: `404` not found
+
+### Health
+
+#### GET /health
+- Response: `200 { status: "ok", timestamp, version }`
+
+### Documentation
+
+#### GET /docs
+- Swagger UI with interactive API documentation
+
+## Requirements
+- TypeScript throughout
+- All inputs validated with zod before processing
+- Consistent error format: `{ error: { code, message, details? } }`
+- No stack traces in production responses
+- Proper HTTP status codes (200, 201, 204, 400, 404, 500)
+- CORS configured via environment variable
+- Request logging with correlation IDs
+- Database migrations managed by Prisma
+
+## Testing
+
+### Unit Tests
+- Pagination cursor encoding and decoding
+- Input validation schemas
+- Slug generation from titles
+- Error formatting
+
+### Integration Tests
+- Full CRUD lifecycle for posts
+- Pagination across multiple pages
+- Filtering by status and search term
+- Sorting in both directions
+- Swagger endpoint serves valid OpenAPI spec
+
+### Test Coverage
+- Target: 85%+ line coverage
+- All error paths tested
+- All validation rules tested
+
+## Out of Scope
+- Authentication and authorization (see `rest-api-auth.md`)
+- User accounts and sessions
+- Rate limiting (see `rest-api-auth.md`)
+- File uploads
+- WebSocket connections
+- Deployment configuration
+- Frontend or UI
+
+## Acceptance Criteria
 - All CRUD endpoints return correct status codes and response shapes
-- JWT auth flow works: register, login, refresh, logout
-- Pagination returns correct pages with proper metadata
-- Rate limiter blocks excessive requests with 429 responses
-- Swagger UI serves interactive documentation
+- Pagination returns correct pages with proper cursor metadata
+- Search and filtering narrow results accurately
+- Swagger UI serves interactive documentation at /docs
+- Invalid inputs return descriptive 400 errors
+- All tests pass with 85%+ coverage
+
+## Success Criteria
+- API starts and responds to all documented endpoints
+- Swagger docs match actual API behavior
+- Seed data loads correctly for development
 - All tests pass
+
+---
+
+**Purpose:** Tests Loki Mode's ability to build a clean REST API with proper HTTP semantics, pagination, validation, and documentation -- without auth complexity. Exercises backend agent and QA agent. Expect ~25-35 minutes for full execution.

package/templates/slack-bot.md

@@ -33,6 +33,54 @@ A Slack bot that responds to commands, processes events, and integrates with ext
 - Error handling verified for invalid inputs and API failures
 - Rate limiting compliance with Slack API limits
 
+## Project Structure
+```
+/
+├── src/
+│   ├── app.ts                 # Bolt app initialization
+│   ├── server.ts              # Entry point (Socket Mode or HTTP)
+│   ├── commands/
+│   │   ├── index.ts           # Command router
+│   │   ├── help.ts            # /help command handler
+│   │   └── remind.ts          # /remind command handler
+│   ├── events/
+│   │   ├── message.ts         # Message event handler
+│   │   └── reaction.ts        # Reaction event handler
+│   ├── actions/
+│   │   └── buttons.ts         # Interactive button handlers
+│   ├── views/
+│   │   └── modals.ts          # Modal view definitions
+│   ├── services/
+│   │   ├── scheduler.ts       # Cron-based scheduled messages
+│   │   └── external.ts        # External API integrations
+│   ├── db.ts                  # SQLite connection and queries
+│   └── config.ts              # Token and config from env
+├── tests/
+│   ├── commands.test.ts       # Command handler tests
+│   └── scheduler.test.ts      # Scheduler logic tests
+├── .env.example               # Required Slack tokens
+├── package.json
+└── README.md
+```
+
+## Out of Scope
+- OAuth installation flow for multi-workspace distribution
+- Slack App Directory submission
+- Real-time messaging API (RTM) -- use Events API instead
+- Message threading and conversation management
+- File upload or download handling
+- Workflow Builder integration
+- Slack Connect (cross-org) support
+
+## Acceptance Criteria
+- Bot connects via Socket Mode in development
+- All slash commands parse arguments and return formatted responses
+- Message events trigger the correct handler based on content
+- Interactive buttons and modals submit data and update the original message
+- Scheduled messages fire within 60 seconds of their configured time
+- Failed commands send an error notification to the admin channel
+- Help command lists all registered commands with usage examples
+
 ## Success Metrics
 - Bot responds to all registered slash commands
 - Event handlers process messages and reactions correctly

package/templates/web-scraper.md

@@ -33,6 +33,51 @@ A configurable web scraping tool that extracts structured data from websites, ha
 - Rate limiter verified with timing assertions
 - Export format validation for JSON, CSV, and SQLite
 
+## Project Structure
+```
+/
+├── src/
+│   ├── scraper/
+│   │   ├── engine.py          # Main scraping orchestrator
+│   │   ├── fetcher.py         # Async HTTP client with retries
+│   │   ├── parser.py          # CSS/XPath extraction logic
+│   │   └── pagination.py      # Next-page detection and following
+│   ├── compliance/
+│   │   └── robots.py          # robots.txt parser and enforcer
+│   ├── export/
+│   │   ├── json_export.py     # JSON file writer
+│   │   ├── csv_export.py      # CSV file writer
+│   │   └── sqlite_export.py   # SQLite database writer
+│   ├── cli.py                 # CLI entrypoint (argparse)
+│   └── config.py              # YAML config loader
+├── configs/
+│   └── example.yaml           # Sample scraping target definition
+├── tests/
+│   ├── test_parser.py         # Extraction logic tests
+│   ├── test_robots.py         # robots.txt compliance tests
+│   └── test_export.py         # Export format tests
+├── pyproject.toml
+└── README.md
+```
+
+## Out of Scope
+- JavaScript-rendered pages (Puppeteer, Playwright)
+- CAPTCHA solving or bypass
+- Login-required or session-based scraping
+- Distributed scraping across multiple machines
+- Web UI for configuring scraping jobs
+- Data deduplication across runs
+- Cloud storage export (S3, GCS)
+
+## Acceptance Criteria
+- YAML config defines target URL, CSS selectors, and field names
+- Scraper extracts all matching elements from a page
+- Pagination follows next-page links until no more pages remain
+- Requests are spaced by the configured delay interval
+- robots.txt disallow rules prevent scraping blocked paths
+- JSON, CSV, and SQLite exports all contain identical data
+- Failed requests retry with exponential backoff up to 3 times
+
 ## Success Metrics
 - Scraper extracts data matching CSS selector configuration
 - Pagination follows links and collects all pages