@jigyasudham/veto 3.1.0 → 3.1.2

package/dist/skills/development/skill-auth.js

@@ -1,255 +0,0 @@
-// Skill: auth — JWT + bcrypt + refresh token implementation guide
-const TEMPLATE = `
-// ── Types (src/models/auth.ts) ────────────────────────────────────────────
-export interface User {
-  id: string;
-  email: string;
-  passwordHash: string;
-  role: 'admin' | 'user';
-  failedLoginAttempts: number;
-  lockedUntil?: Date | null;
-  createdAt: Date;
-}
-
-export interface TokenPair {
-  accessToken: string;   // short-lived, stateless JWT
-  refreshToken: string;  // long-lived, stored in DB
-}
-
-// ── Token utilities (src/utils/tokens.ts) ────────────────────────────────
-import jwt from 'jsonwebtoken';
-import crypto from 'crypto';
-
-const ACCESS_SECRET = process.env.JWT_ACCESS_SECRET!;   // 256-bit random
-const REFRESH_SECRET = process.env.JWT_REFRESH_SECRET!; // separate secret
-const ACCESS_TTL = '15m';
-const REFRESH_TTL = '7d';
-
-export function signAccessToken(userId: string, role: string): string {
-  return jwt.sign({ sub: userId, role }, ACCESS_SECRET, {
-    expiresIn: ACCESS_TTL,
-    algorithm: 'HS256',
-  });
-}
-
-export function verifyAccessToken(token: string): { sub: string; role: string } {
-  return jwt.verify(token, ACCESS_SECRET, { algorithms: ['HS256'] }) as { sub: string; role: string };
-}
-
-export function generateRefreshToken(): string {
-  return crypto.randomBytes(64).toString('hex'); // 512 bits of entropy
-}
-
-// ── Auth service (src/services/auth.service.ts) ───────────────────────────
-import bcrypt from 'bcrypt';
-
-const BCRYPT_ROUNDS = 12;
-const MAX_ATTEMPTS = 5;
-const LOCKOUT_MINUTES = 30;
-
-export class AuthService {
-  constructor(
-    private readonly userRepo: UserRepository,
-    private readonly tokenRepo: RefreshTokenRepository,
-  ) {}
-
-  async register(email: string, password: string): Promise<User> {
-    const existing = await this.userRepo.findByEmail(email);
-    if (existing) throw new ConflictError('Email already registered');
-    const passwordHash = await bcrypt.hash(password, BCRYPT_ROUNDS);
-    return this.userRepo.create({ email: email.toLowerCase().trim(), passwordHash });
-  }
-
-  async login(email: string, password: string): Promise<TokenPair> {
-    const user = await this.userRepo.findByEmail(email.toLowerCase().trim());
-    if (!user) throw new UnauthorizedError('Invalid credentials');
-
-    if (user.lockedUntil && user.lockedUntil > new Date()) {
-      throw new UnauthorizedError('Account locked. Check your email to unlock.');
-    }
-
-    const valid = await bcrypt.compare(password, user.passwordHash);
-    if (!valid) {
-      await this.recordFailedAttempt(user);
-      throw new UnauthorizedError('Invalid credentials');
-    }
-
-    await this.userRepo.resetFailedAttempts(user.id);
-    return this.issueTokenPair(user.id, user.role);
-  }
-
-  async refresh(rawRefreshToken: string): Promise<TokenPair> {
-    const tokenHash = hashToken(rawRefreshToken);
-    const stored = await this.tokenRepo.findByHash(tokenHash);
-    if (!stored || stored.revokedAt || stored.expiresAt < new Date()) {
-      throw new UnauthorizedError('Invalid or expired refresh token');
-    }
-    // Rotate: revoke old, issue new
-    await this.tokenRepo.revoke(stored.id);
-    return this.issueTokenPair(stored.userId, stored.role);
-  }
-
-  async logout(rawRefreshToken: string): Promise<void> {
-    const tokenHash = hashToken(rawRefreshToken);
-    const stored = await this.tokenRepo.findByHash(tokenHash);
-    if (stored) await this.tokenRepo.revoke(stored.id);
-  }
-
-  private async issueTokenPair(userId: string, role: string): Promise<TokenPair> {
-    const rawRefreshToken = generateRefreshToken();
-    await this.tokenRepo.create({
-      userId,
-      tokenHash: hashToken(rawRefreshToken),
-      role,
-      expiresAt: addDays(new Date(), 7),
-    });
-    return {
-      accessToken: signAccessToken(userId, role),
-      refreshToken: rawRefreshToken,
-    };
-  }
-
-  private async recordFailedAttempt(user: User): Promise<void> {
-    const attempts = user.failedLoginAttempts + 1;
-    if (attempts >= MAX_ATTEMPTS) {
-      const lockedUntil = addMinutes(new Date(), LOCKOUT_MINUTES);
-      await this.userRepo.lockAccount(user.id, lockedUntil);
-      // TODO: send unlock email
-    } else {
-      await this.userRepo.incrementFailedAttempts(user.id);
-    }
-  }
-}
-
-// ── Auth middleware (src/middleware/auth.ts) ───────────────────────────────
-import { Request, Response, NextFunction } from 'express';
-
-export function requireAuth(req: Request, res: Response, next: NextFunction): void {
-  const header = req.headers.authorization;
-  if (!header?.startsWith('Bearer ')) {
-    res.status(401).json({ error: 'Missing or malformed Authorization header' });
-    return;
-  }
-  try {
-    const payload = verifyAccessToken(header.slice(7));
-    req.user = { id: payload.sub, role: payload.role };
-    next();
-  } catch {
-    res.status(401).json({ error: 'Invalid or expired access token' });
-  }
-}
-
-export function requireRole(role: string) {
-  return (req: Request, res: Response, next: NextFunction): void => {
-    if (req.user?.role !== role) {
-      res.status(403).json({ error: 'Insufficient permissions' });
-      return;
-    }
-    next();
-  };
-}
-
-// ── Auth routes (src/routes/auth.ts) ─────────────────────────────────────
-import { Router } from 'express';
-import { z } from 'zod';
-import rateLimit from 'express-rate-limit';
-
-const authLimiter = rateLimit({ windowMs: 15 * 60 * 1000, max: 10, standardHeaders: true });
-
-const RegisterSchema = z.object({
-  email: z.string().email().max(255),
-  password: z.string().min(12).max(128),
-});
-
-const LoginSchema = RegisterSchema;
-
-export function createAuthRouter(service: AuthService): Router {
-  const router = Router();
-  router.use(authLimiter);
-
-  router.post('/register', validate(RegisterSchema), async (req, res) => {
-    const user = await service.register(req.body.email, req.body.password);
-    res.status(201).json({ data: { id: user.id, email: user.email } });
-  });
-
-  router.post('/login', validate(LoginSchema), async (req, res) => {
-    const tokens = await service.login(req.body.email, req.body.password);
-    res
-      .cookie('refreshToken', tokens.refreshToken, {
-        httpOnly: true, secure: true, sameSite: 'strict', maxAge: 7 * 24 * 60 * 60 * 1000,
-      })
-      .json({ data: { accessToken: tokens.accessToken } });
-  });
-
-  router.post('/refresh', async (req, res) => {
-    const raw = req.cookies?.refreshToken;
-    if (!raw) { res.status(401).json({ error: 'No refresh token' }); return; }
-    const tokens = await service.refresh(raw);
-    res
-      .cookie('refreshToken', tokens.refreshToken, {
-        httpOnly: true, secure: true, sameSite: 'strict', maxAge: 7 * 24 * 60 * 60 * 1000,
-      })
-      .json({ data: { accessToken: tokens.accessToken } });
-  });
-
-  router.post('/logout', async (req, res) => {
-    const raw = req.cookies?.refreshToken;
-    if (raw) await service.logout(raw);
-    res.clearCookie('refreshToken').status(204).send();
-  });
-
-  return router;
-}
-`.trim();
-export function run(input) {
-    return {
-        skill: 'auth',
-        template: TEMPLATE,
-        checklist: [
-            'Install: npm install bcrypt jsonwebtoken cookie-parser express-rate-limit && npm install -D @types/bcrypt @types/jsonwebtoken @types/cookie-parser',
-            'Generate two separate 256-bit secrets: JWT_ACCESS_SECRET and JWT_REFRESH_SECRET via crypto.randomBytes(32).toString("hex")',
-            'Store both secrets in environment variables; never hardcode them',
-            'Implement User model with passwordHash (never password), failedLoginAttempts, lockedUntil fields',
-            'Implement RefreshToken model with userId, tokenHash (SHA-256 of raw token), expiresAt, revokedAt',
-            'Set bcrypt cost factor to 12; adjust up if server can handle the latency',
-            'Set access token TTL to 15 minutes; set refresh token TTL to 7 days',
-            'Always call jwt.verify with explicit { algorithms: ["HS256"] } — never allow alg negotiation',
-            'Implement refresh token rotation: revoke old token, issue new token on every /refresh call',
-            'Store the SHA-256 hash of the refresh token in DB, never the raw value',
-            'Deliver access token in response body; deliver refresh token in httpOnly Secure SameSite=Strict cookie',
-            'Apply express-rate-limit (10 req/15 min) to all auth endpoints',
-            'Implement account lockout: after 5 failures, lock for 30 minutes and send unlock email',
-            'Normalise email input: .toLowerCase().trim() before lookup or storage',
-            'Return identical error messages for invalid credentials regardless of whether user exists (prevents enumeration)',
-            'Implement /logout that revokes refresh token from DB and clears cookie',
-            'Implement password reset: generate a single-use HMAC token, send via email, expire in 1 hour',
-            'Log every auth event (login success/fail, logout, token refresh, lockout) with userId, IP, user-agent',
-            'Write unit tests for AuthService mocking repositories',
-            'Write integration tests: register → login → refresh → logout → verify refresh fails after logout',
-        ],
-        patterns: [
-            'Stateless access token + stateful refresh token hybrid',
-            'Refresh token rotation with database revocation',
-            'httpOnly cookie for refresh token (XSS-safe delivery)',
-            'Hash-before-store for refresh tokens (never store raw token)',
-            'Rate limiter middleware applied at router level, not per-route',
-        ],
-        gotchas: [
-            'Not rotating refresh tokens on use — a stolen refresh token can be used indefinitely',
-            'Accepting jwt.verify without specifying algorithms — "alg":"none" bypass attack',
-            'Storing refresh tokens in localStorage — immediately exposed to any XSS vulnerability',
-            'Using a short bcrypt salt rounds (< 10) — trivial brute force offline after DB leak',
-            'Reusing the same secret for access and refresh tokens — compromise of one breaks both',
-            'Not invalidating access tokens on logout — they remain valid until expiry (15 min window)',
-            'Not sending identical error messages for bad username vs bad password — enables enumeration',
-        ],
-        resources: [
-            'https://www.npmjs.com/package/jsonwebtoken',
-            'https://www.npmjs.com/package/bcrypt',
-            'https://cheatsheetseries.owasp.org/cheatsheets/Authentication_Cheat_Sheet.html',
-            'https://cheatsheetseries.owasp.org/cheatsheets/JSON_Web_Token_for_Java_Cheat_Sheet.html',
-            'https://datatracker.ietf.org/doc/html/rfc6749 (OAuth 2.0)',
-        ],
-    };
-}
-//# sourceMappingURL=skill-auth.js.map

package/dist/skills/development/skill-auth.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-auth.js","sourceRoot":"","sources":["../../../src/skills/development/skill-auth.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAiBlE,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyMhB,CAAC,IAAI,EAAE,CAAC;AAET,MAAM,UAAU,GAAG,CAAC,KAAiB;IACnC,OAAO;QACL,KAAK,EAAE,MAAM;QACb,QAAQ,EAAE,QAAQ;QAClB,SAAS,EAAE;YACT,oJAAoJ;YACpJ,4HAA4H;YAC5H,kEAAkE;YAClE,kGAAkG;YAClG,kGAAkG;YAClG,0EAA0E;YAC1E,qEAAqE;YACrE,8FAA8F;YAC9F,4FAA4F;YAC5F,wEAAwE;YACxE,wGAAwG;YACxG,gEAAgE;YAChE,wFAAwF;YACxF,uEAAuE;YACvE,kHAAkH;YAClH,wEAAwE;YACxE,8FAA8F;YAC9F,uGAAuG;YACvG,uDAAuD;YACvD,kGAAkG;SACnG;QACD,QAAQ,EAAE;YACR,wDAAwD;YACxD,iDAAiD;YACjD,uDAAuD;YACvD,8DAA8D;YAC9D,gEAAgE;SACjE;QACD,OAAO,EAAE;YACP,sFAAsF;YACtF,iFAAiF;YACjF,uFAAuF;YACvF,qFAAqF;YACrF,uFAAuF;YACvF,2FAA2F;YAC3F,6FAA6F;SAC9F;QACD,SAAS,EAAE;YACT,4CAA4C;YAC5C,sCAAsC;YACtC,gFAAgF;YAChF,yFAAyF;YACzF,2DAA2D;SAC5D;KACF,CAAC;AACJ,CAAC"}

package/dist/skills/development/skill-ci-cd.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=skill-ci-cd.d.ts.map

package/dist/skills/development/skill-ci-cd.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-ci-cd.d.ts","sourceRoot":"","sources":["../../../src/skills/development/skill-ci-cd.ts"],"names":[],"mappings":""}

package/dist/skills/development/skill-ci-cd.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=skill-ci-cd.js.map

package/dist/skills/development/skill-ci-cd.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-ci-cd.js","sourceRoot":"","sources":["../../../src/skills/development/skill-ci-cd.ts"],"names":[],"mappings":""}

package/dist/skills/development/skill-crud.d.ts

@@ -1,15 +0,0 @@
-export interface SkillInput {
-    task: string;
-    context?: string;
-    options?: Record<string, unknown>;
-}
-export interface SkillOutput {
-    skill: string;
-    template?: string;
-    checklist: string[];
-    patterns: string[];
-    gotchas: string[];
-    resources: string[];
-}
-export declare function run(input: SkillInput): SkillOutput;
-//# sourceMappingURL=skill-crud.d.ts.map

package/dist/skills/development/skill-crud.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-crud.d.ts","sourceRoot":"","sources":["../../../src/skills/development/skill-crud.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAmJD,wBAAgB,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CA8ClD"}

package/dist/skills/development/skill-crud.js

@@ -1,193 +0,0 @@
-// Skill: crud — complete CRUD implementation guide
-const TEMPLATE = `
-// ── 1. Model (src/models/item.ts) ─────────────────────────────────────────
-export interface Item {
-  id: string;
-  name: string;
-  description?: string;
-  userId: string;       // ownership field — always include
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-export interface CreateItemInput {
-  name: string;
-  description?: string;
-}
-
-export interface UpdateItemInput {
-  name?: string;
-  description?: string;
-}
-
-// ── 2. Repository (src/repositories/item.repository.ts) ──────────────────
-export interface ItemRepository {
-  findById(id: string): Promise<Item | null>;
-  findAllByUser(userId: string): Promise<Item[]>;
-  create(userId: string, input: CreateItemInput): Promise<Item>;
-  update(id: string, input: UpdateItemInput): Promise<Item>;
-  delete(id: string): Promise<void>;
-}
-
-// PrismaItemRepository implements ItemRepository
-export class PrismaItemRepository implements ItemRepository {
-  constructor(private readonly db: PrismaClient) {}
-
-  async findById(id: string): Promise<Item | null> {
-    return this.db.item.findUnique({ where: { id } });
-  }
-
-  async findAllByUser(userId: string): Promise<Item[]> {
-    return this.db.item.findMany({ where: { userId }, orderBy: { createdAt: 'desc' } });
-  }
-
-  async create(userId: string, input: CreateItemInput): Promise<Item> {
-    return this.db.item.create({ data: { ...input, userId } });
-  }
-
-  async update(id: string, input: UpdateItemInput): Promise<Item> {
-    return this.db.item.update({ where: { id }, data: input });
-  }
-
-  async delete(id: string): Promise<void> {
-    await this.db.item.delete({ where: { id } });
-  }
-}
-
-// ── 3. Service (src/services/item.service.ts) ────────────────────────────
-export class ItemService {
-  constructor(private readonly repo: ItemRepository) {}
-
-  async getItem(id: string, requestingUserId: string): Promise<Item> {
-    const item = await this.repo.findById(id);
-    if (!item) throw new NotFoundError('Item not found');
-    if (item.userId !== requestingUserId) throw new ForbiddenError('Access denied');
-    return item;
-  }
-
-  async listItems(userId: string): Promise<Item[]> {
-    return this.repo.findAllByUser(userId);
-  }
-
-  async createItem(userId: string, input: CreateItemInput): Promise<Item> {
-    return this.repo.create(userId, input);
-  }
-
-  async updateItem(id: string, input: UpdateItemInput, requestingUserId: string): Promise<Item> {
-    await this.getItem(id, requestingUserId); // throws if not found or not owned
-    return this.repo.update(id, input);
-  }
-
-  async deleteItem(id: string, requestingUserId: string): Promise<void> {
-    await this.getItem(id, requestingUserId); // ownership check
-    return this.repo.delete(id);
-  }
-}
-
-// ── 4. Controller (src/controllers/item.controller.ts) ───────────────────
-export class ItemController {
-  constructor(private readonly service: ItemService) {}
-
-  // GET /items
-  list = async (req: Request, res: Response): Promise<void> => {
-    const items = await this.service.listItems(req.user.id);
-    res.json({ data: items });
-  };
-
-  // GET /items/:id
-  get = async (req: Request, res: Response): Promise<void> => {
-    const item = await this.service.getItem(req.params.id, req.user.id);
-    res.json({ data: item });
-  };
-
-  // POST /items
-  create = async (req: Request, res: Response): Promise<void> => {
-    const item = await this.service.createItem(req.user.id, req.body);
-    res.status(201).json({ data: item });
-  };
-
-  // PATCH /items/:id
-  update = async (req: Request, res: Response): Promise<void> => {
-    const item = await this.service.updateItem(req.params.id, req.body, req.user.id);
-    res.json({ data: item });
-  };
-
-  // DELETE /items/:id
-  delete = async (req: Request, res: Response): Promise<void> => {
-    await this.service.deleteItem(req.params.id, req.user.id);
-    res.status(204).send();
-  };
-}
-
-// ── 5. Routes (src/routes/items.ts) ─────────────────────────────────────
-import { Router } from 'express';
-import { z } from 'zod';
-
-const CreateItemSchema = z.object({
-  name: z.string().min(1).max(100),
-  description: z.string().max(500).optional(),
-});
-
-const UpdateItemSchema = z.object({
-  name: z.string().min(1).max(100).optional(),
-  description: z.string().max(500).optional(),
-}).refine(obj => Object.keys(obj).length > 0, { message: 'At least one field required' });
-
-export function createItemRouter(controller: ItemController): Router {
-  const router = Router();
-  router.get('/', controller.list);
-  router.get('/:id', controller.get);
-  router.post('/', validate(CreateItemSchema), controller.create);
-  router.patch('/:id', validate(UpdateItemSchema), controller.update);
-  router.delete('/:id', controller.delete);
-  return router;
-}
-`.trim();
-export function run(input) {
-    return {
-        skill: 'crud',
-        template: TEMPLATE,
-        checklist: [
-            'Define TypeScript model interface with id, ownership field (userId), createdAt, updatedAt',
-            'Define separate CreateInput and UpdateInput types (no id, no userId, all update fields optional)',
-            'Create repository interface — program to the interface, not the implementation',
-            'Implement repository with Prisma/Drizzle/raw queries; keep DB logic isolated here',
-            'Implement service layer: all ownership and business rule checks happen here',
-            'Add service method getById that always checks ownership before returning data',
-            'Implement controller: parse request → call service → format response; no DB access',
-            'Create Zod schemas for create and update request bodies',
-            'Add validate middleware that runs Zod schema and returns 400 on failure',
-            'Register routes: GET / (list), GET /:id, POST / (create), PATCH /:id, DELETE /:id',
-            'Mount routes behind auth middleware so req.user is always populated',
-            'Add 204 No Content for successful DELETE (no body)',
-            'Add 201 Created with Location header for successful POST',
-            'Write unit tests for service layer (mock the repository)',
-            'Write integration tests covering happy path, 404, 403 (wrong user), 400 (bad input)',
-            'Add pagination to the list endpoint: limit/offset or cursor-based',
-            'Add filtering and sorting parameters to the list endpoint',
-            'Document all endpoints with JSDoc or OpenAPI comments',
-        ],
-        patterns: [
-            'Controller → Service → Repository three-layer architecture',
-            'Repository pattern: data access is behind an interface for testability',
-            'Ownership check in every service read/write operation (prevents IDOR)',
-            'Zod schema validation at the route boundary',
-            'Error-first service methods: throw typed errors, not returning null for auth failures',
-        ],
-        gotchas: [
-            'Forgetting ownership check in the service — returns any user\'s data via IDOR',
-            'Putting DB queries directly in controllers — bypasses repository layer and breaks tests',
-            'Not returning 404 before 403 — leaks resource existence to unauthorised users (use 404 for both)',
-            'Updating with empty body — add a Zod refine check that at least one field is present for PATCH',
-            'Not invalidating caches after update/delete — stale data returned to other users',
-            'Using findMany without a userId filter on list — returns all users\' data',
-        ],
-        resources: [
-            'https://www.prisma.io/docs/concepts/components/prisma-client/crud',
-            'https://zod.dev/',
-            'https://owasp.org/www-project-api-security/ (API4:2023 Broken Object Level Authorization)',
-            'https://expressjs.com/en/guide/routing.html',
-        ],
-    };
-}
-//# sourceMappingURL=skill-crud.js.map

package/dist/skills/development/skill-crud.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-crud.js","sourceRoot":"","sources":["../../../src/skills/development/skill-crud.ts"],"names":[],"mappings":"AAAA,mDAAmD;AAiBnD,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+IhB,CAAC,IAAI,EAAE,CAAC;AAET,MAAM,UAAU,GAAG,CAAC,KAAiB;IACnC,OAAO;QACL,KAAK,EAAE,MAAM;QACb,QAAQ,EAAE,QAAQ;QAClB,SAAS,EAAE;YACT,2FAA2F;YAC3F,kGAAkG;YAClG,gFAAgF;YAChF,mFAAmF;YACnF,6EAA6E;YAC7E,+EAA+E;YAC/E,oFAAoF;YACpF,yDAAyD;YACzD,yEAAyE;YACzE,mFAAmF;YACnF,qEAAqE;YACrE,oDAAoD;YACpD,0DAA0D;YAC1D,0DAA0D;YAC1D,qFAAqF;YACrF,mEAAmE;YACnE,2DAA2D;YAC3D,uDAAuD;SACxD;QACD,QAAQ,EAAE;YACR,4DAA4D;YAC5D,wEAAwE;YACxE,uEAAuE;YACvE,6CAA6C;YAC7C,uFAAuF;SACxF;QACD,OAAO,EAAE;YACP,+EAA+E;YAC/E,yFAAyF;YACzF,kGAAkG;YAClG,gGAAgG;YAChG,kFAAkF;YAClF,2EAA2E;SAC5E;QACD,SAAS,EAAE;YACT,mEAAmE;YACnE,kBAAkB;YAClB,2FAA2F;YAC3F,6CAA6C;SAC9C;KACF,CAAC;AACJ,CAAC"}

package/dist/skills/development/skill-db-schema.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=skill-db-schema.d.ts.map

package/dist/skills/development/skill-db-schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-db-schema.d.ts","sourceRoot":"","sources":["../../../src/skills/development/skill-db-schema.ts"],"names":[],"mappings":""}

package/dist/skills/development/skill-db-schema.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=skill-db-schema.js.map

package/dist/skills/development/skill-db-schema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-db-schema.js","sourceRoot":"","sources":["../../../src/skills/development/skill-db-schema.ts"],"names":[],"mappings":""}

package/dist/skills/development/skill-docker.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=skill-docker.d.ts.map

package/dist/skills/development/skill-docker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-docker.d.ts","sourceRoot":"","sources":["../../../src/skills/development/skill-docker.ts"],"names":[],"mappings":""}

package/dist/skills/development/skill-docker.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=skill-docker.js.map

package/dist/skills/development/skill-docker.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-docker.js","sourceRoot":"","sources":["../../../src/skills/development/skill-docker.ts"],"names":[],"mappings":""}

package/dist/skills/development/skill-env-setup.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=skill-env-setup.d.ts.map

package/dist/skills/development/skill-env-setup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-env-setup.d.ts","sourceRoot":"","sources":["../../../src/skills/development/skill-env-setup.ts"],"names":[],"mappings":""}

package/dist/skills/development/skill-env-setup.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=skill-env-setup.js.map

package/dist/skills/development/skill-env-setup.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-env-setup.js","sourceRoot":"","sources":["../../../src/skills/development/skill-env-setup.ts"],"names":[],"mappings":""}

package/dist/skills/development/skill-scaffold.d.ts

@@ -1,15 +0,0 @@
-export interface SkillInput {
-    task: string;
-    context?: string;
-    options?: Record<string, unknown>;
-}
-export interface SkillOutput {
-    skill: string;
-    template?: string;
-    checklist: string[];
-    patterns: string[];
-    gotchas: string[];
-    resources: string[];
-}
-export declare function run(input: SkillInput): SkillOutput;
-//# sourceMappingURL=skill-scaffold.d.ts.map

package/dist/skills/development/skill-scaffold.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-scaffold.d.ts","sourceRoot":"","sources":["../../../src/skills/development/skill-scaffold.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAwSD,wBAAgB,GAAG,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAWlD"}