@skillkit/resources 1.8.0

package/dist/index.js

@@ -0,0 +1,991 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/agents/index.ts
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+
+// src/agents/manifest.ts
+var BUNDLED_AGENTS = [
+  {
+    id: "architect",
+    name: "Architect",
+    description: "Software architecture specialist for system design, scalability, and technical decision-making",
+    category: "planning",
+    model: "opus",
+    tools: ["Read", "Grep", "Glob"],
+    tags: ["architecture", "design", "planning", "scalability"],
+    version: "1.0.0"
+  },
+  {
+    id: "build-error-resolver",
+    name: "Build Error Resolver",
+    description: "Build and TypeScript error resolution specialist. Fixes build/type errors with minimal diffs",
+    category: "development",
+    model: "sonnet",
+    tools: ["Read", "Write", "Edit", "Bash", "Grep", "Glob"],
+    tags: ["build", "typescript", "errors", "debugging"],
+    version: "1.0.0"
+  },
+  {
+    id: "code-reviewer",
+    name: "Code Reviewer",
+    description: "Expert code review specialist. Reviews code for quality, security, and maintainability",
+    category: "review",
+    model: "sonnet",
+    tools: ["Read", "Grep", "Glob", "Bash"],
+    tags: ["review", "quality", "best-practices"],
+    version: "1.0.0"
+  },
+  {
+    id: "doc-updater",
+    name: "Documentation Updater",
+    description: "Documentation and codemap specialist. Updates codemaps, READMEs, and guides",
+    category: "documentation",
+    model: "sonnet",
+    tools: ["Read", "Write", "Edit", "Bash", "Grep", "Glob"],
+    tags: ["documentation", "readme", "guides"],
+    version: "1.0.0"
+  },
+  {
+    id: "e2e-runner",
+    name: "E2E Test Runner",
+    description: "End-to-end testing specialist using Playwright. Generates, maintains, and runs E2E tests",
+    category: "testing",
+    model: "sonnet",
+    tools: ["Read", "Write", "Edit", "Bash", "Grep", "Glob"],
+    tags: ["testing", "e2e", "playwright", "automation"],
+    version: "1.0.0"
+  },
+  {
+    id: "planner",
+    name: "Implementation Planner",
+    description: "Expert planning specialist for complex features and refactoring. Creates step-by-step plans",
+    category: "planning",
+    model: "opus",
+    tools: ["Read", "Grep", "Glob"],
+    tags: ["planning", "design", "architecture"],
+    version: "1.0.0"
+  },
+  {
+    id: "refactor-cleaner",
+    name: "Refactor & Clean",
+    description: "Dead code cleanup and consolidation specialist. Removes unused code and duplicates",
+    category: "refactoring",
+    model: "sonnet",
+    tools: ["Read", "Write", "Edit", "Bash", "Grep", "Glob"],
+    tags: ["refactoring", "cleanup", "dead-code"],
+    version: "1.0.0"
+  },
+  {
+    id: "security-reviewer",
+    name: "Security Reviewer",
+    description: "Security vulnerability detection and remediation specialist. OWASP Top 10, secrets, injection",
+    category: "security",
+    model: "opus",
+    tools: ["Read", "Write", "Edit", "Bash", "Grep", "Glob"],
+    tags: ["security", "vulnerabilities", "owasp", "audit"],
+    version: "1.0.0"
+  },
+  {
+    id: "tdd-guide",
+    name: "TDD Guide",
+    description: "Test-Driven Development specialist. Write tests first, then implement minimal code to pass",
+    category: "testing",
+    model: "sonnet",
+    tools: ["Read", "Write", "Edit", "Bash", "Grep"],
+    tags: ["testing", "tdd", "unit-tests", "coverage"],
+    version: "1.0.0"
+  }
+];
+var AGENT_MANIFEST = {
+  version: 1,
+  agents: BUNDLED_AGENTS
+};
+
+// src/agents/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function getTemplatesDir() {
+  return join(__dirname, "..", "..", "templates", "agents");
+}
+function getBundledAgents() {
+  return BUNDLED_AGENTS;
+}
+function getBundledAgent(id) {
+  return BUNDLED_AGENTS.find((a) => a.id === id) || null;
+}
+function getBundledAgentsByCategory(category) {
+  return BUNDLED_AGENTS.filter((a) => a.category === category);
+}
+function getBundledAgentIds() {
+  return BUNDLED_AGENTS.map((a) => a.id);
+}
+function getAgentTemplate(id) {
+  const agent = getBundledAgent(id);
+  if (!agent) return null;
+  const templatePath = join(getTemplatesDir(), `${id}.md`);
+  try {
+    if (existsSync(templatePath)) {
+      return readFileSync(templatePath, "utf-8");
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function installBundledAgent(id, options = {}) {
+  const agent = getBundledAgent(id);
+  if (!agent) {
+    return {
+      success: false,
+      agentId: id,
+      path: "",
+      message: `Bundled agent not found: ${id}`
+    };
+  }
+  const template = getAgentTemplate(id);
+  if (!template) {
+    return {
+      success: false,
+      agentId: id,
+      path: "",
+      message: `Template not found for agent: ${id}`
+    };
+  }
+  let targetDir;
+  if (options.targetDir) {
+    targetDir = options.targetDir;
+  } else if (options.global) {
+    targetDir = join(homedir(), ".claude", "agents");
+  } else {
+    targetDir = join(process.cwd(), ".claude", "agents");
+  }
+  const targetPath = join(targetDir, `${id}.md`);
+  if (existsSync(targetPath) && !options.force) {
+    return {
+      success: false,
+      agentId: id,
+      path: targetPath,
+      message: `Agent already exists: ${targetPath}. Use --force to overwrite.`
+    };
+  }
+  try {
+    if (!existsSync(targetDir)) {
+      mkdirSync(targetDir, { recursive: true });
+    }
+    writeFileSync(targetPath, template);
+    return {
+      success: true,
+      agentId: id,
+      path: targetPath,
+      message: `Installed agent: ${agent.name}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      agentId: id,
+      path: targetPath,
+      message: `Failed to install agent: ${error instanceof Error ? error.message : "Unknown error"}`
+    };
+  }
+}
+function getInstalledAgentIds(searchDirs) {
+  const dirs = searchDirs || [
+    join(process.cwd(), ".claude", "agents"),
+    join(homedir(), ".claude", "agents")
+  ];
+  const installed = /* @__PURE__ */ new Set();
+  for (const dir of dirs) {
+    if (existsSync(dir)) {
+      try {
+        const files = __require("fs").readdirSync(dir);
+        for (const file of files) {
+          if (file.endsWith(".md")) {
+            installed.add(file.replace(".md", ""));
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  return Array.from(installed);
+}
+function getAvailableAgents(searchDirs) {
+  const installed = new Set(getInstalledAgentIds(searchDirs));
+  return BUNDLED_AGENTS.filter((a) => !installed.has(a.id));
+}
+function isAgentInstalled(id, searchDirs) {
+  return getInstalledAgentIds(searchDirs).includes(id);
+}
+
+// src/commands/manifest.ts
+var COMMAND_TEMPLATES = [
+  {
+    id: "tdd",
+    name: "TDD Workflow",
+    description: "Test-Driven Development workflow: RED \u2192 GREEN \u2192 REFACTOR",
+    category: "testing",
+    trigger: "/tdd",
+    agent: "tdd-guide",
+    prompt: `Start TDD workflow for the requested feature or fix.
+
+Follow the RED \u2192 GREEN \u2192 REFACTOR cycle:
+
+1. **RED**: Write a failing test that describes the expected behavior
+2. **GREEN**: Write the minimum code needed to pass the test
+3. **REFACTOR**: Improve the code while keeping tests green
+
+Guidelines:
+- One test at a time
+- Tests should be small and focused
+- Commit after each GREEN phase
+- Keep refactoring incremental
+
+Start by asking: What behavior should we test first?`,
+    examples: [
+      "/tdd add validation to user form",
+      "/tdd implement search functionality"
+    ]
+  },
+  {
+    id: "plan",
+    name: "Implementation Planning",
+    description: "Create a detailed implementation plan before coding",
+    category: "planning",
+    trigger: "/plan",
+    agent: "planner",
+    prompt: `Create an implementation plan for the requested feature or change.
+
+Include:
+1. Requirements analysis
+2. Current state assessment
+3. Proposed approach with alternatives
+4. Step-by-step implementation tasks
+5. Risk assessment and mitigations
+6. Verification criteria
+
+Wait for plan approval before any implementation.`,
+    examples: [
+      "/plan add user authentication",
+      "/plan refactor payment module"
+    ]
+  },
+  {
+    id: "e2e",
+    name: "E2E Test Generation",
+    description: "Generate and run end-to-end tests with Playwright",
+    category: "testing",
+    trigger: "/e2e",
+    agent: "e2e-runner",
+    prompt: `Generate E2E tests for the specified user journey.
+
+Process:
+1. Analyze the user flow to test
+2. Generate Playwright test code
+3. Run the test
+4. Capture screenshots/videos if needed
+5. Report results
+
+Focus on testing critical user paths with reliable selectors.`,
+    examples: [
+      "/e2e test user login flow",
+      "/e2e test checkout process"
+    ]
+  },
+  {
+    id: "learn",
+    name: "Extract Learnings",
+    description: "Extract reusable patterns from the current session",
+    category: "learning",
+    trigger: "/learn",
+    prompt: `Analyze the current session and extract reusable patterns.
+
+Look for:
+1. Error fixes that could apply to similar situations
+2. Workarounds for library/framework quirks
+3. Effective debugging approaches
+4. Project-specific conventions discovered
+
+Format each learning as:
+- Problem: What issue was encountered
+- Solution: How it was resolved
+- Context: When this applies
+- Example: Code snippet if relevant
+
+Ask for approval before saving patterns.`,
+    examples: [
+      "/learn from this debugging session",
+      "/learn extract patterns from recent fixes"
+    ]
+  },
+  {
+    id: "build-fix",
+    name: "Build Error Resolution",
+    description: "Fix build errors with minimal changes",
+    category: "development",
+    trigger: "/build-fix",
+    agent: "build-error-resolver",
+    prompt: `Fix the current build/type errors.
+
+Process:
+1. Run the build to capture all errors
+2. Analyze each error's root cause
+3. Apply minimal fixes (no refactoring)
+4. Verify the build passes
+5. Run tests to ensure no regressions
+
+Focus on getting the build green quickly with the smallest possible changes.`,
+    examples: [
+      "/build-fix",
+      "/build-fix typescript errors"
+    ]
+  },
+  {
+    id: "code-review",
+    name: "Code Review",
+    description: "Review code changes for quality and security",
+    category: "review",
+    trigger: "/code-review",
+    agent: "code-reviewer",
+    prompt: `Review the specified code changes.
+
+Check for:
+1. Correctness and edge cases
+2. Security vulnerabilities
+3. Performance issues
+4. Code quality and maintainability
+5. Test coverage
+
+Provide actionable feedback prioritized by severity.`,
+    examples: [
+      "/code-review recent changes",
+      "/code-review src/auth/"
+    ]
+  },
+  {
+    id: "security-review",
+    name: "Security Review",
+    description: "Audit code for security vulnerabilities",
+    category: "review",
+    trigger: "/security-review",
+    agent: "security-reviewer",
+    prompt: `Perform a security audit of the specified code.
+
+Check for:
+1. OWASP Top 10 vulnerabilities
+2. Hardcoded secrets or credentials
+3. Input validation issues
+4. Authentication/authorization flaws
+5. Data exposure risks
+
+Report findings with severity and remediation steps.`,
+    examples: [
+      "/security-review",
+      "/security-review src/api/"
+    ]
+  },
+  {
+    id: "checkpoint",
+    name: "Create Checkpoint",
+    description: "Create a verification checkpoint for current state",
+    category: "workflow",
+    trigger: "/checkpoint",
+    prompt: `Create a checkpoint to verify the current implementation state.
+
+1. Summarize changes made so far
+2. Run all relevant tests
+3. Check build status
+4. Note any pending issues
+5. Save context for potential recovery
+
+This helps ensure work can be resumed or rolled back if needed.`,
+    examples: [
+      "/checkpoint before major refactor",
+      "/checkpoint feature complete"
+    ]
+  },
+  {
+    id: "verify",
+    name: "Verification Loop",
+    description: "Run comprehensive verification of recent changes",
+    category: "workflow",
+    trigger: "/verify",
+    prompt: `Run verification loop for recent changes.
+
+Steps:
+1. Type check (tsc --noEmit)
+2. Lint check (eslint)
+3. Unit tests
+4. Build verification
+5. Integration tests (if applicable)
+
+Report status and any failures that need attention.`,
+    examples: [
+      "/verify",
+      "/verify all"
+    ]
+  },
+  {
+    id: "cleanup",
+    name: "Code Cleanup",
+    description: "Remove dead code and consolidate duplicates",
+    category: "development",
+    trigger: "/cleanup",
+    agent: "refactor-cleaner",
+    prompt: `Analyze and clean up the codebase.
+
+1. Run dead code analysis (knip, ts-prune)
+2. Identify unused exports and dependencies
+3. Find duplicate code patterns
+4. Remove with verification
+5. Update imports as needed
+
+Make incremental changes with tests passing at each step.`,
+    examples: [
+      "/cleanup",
+      "/cleanup src/utils/"
+    ]
+  }
+];
+var COMMAND_MANIFEST = {
+  version: 1,
+  commands: COMMAND_TEMPLATES
+};
+
+// src/commands/index.ts
+function getCommandTemplates() {
+  return COMMAND_TEMPLATES;
+}
+function getCommandTemplate(id) {
+  return COMMAND_TEMPLATES.find((c) => c.id === id) || null;
+}
+function getCommandByTrigger(trigger) {
+  const normalizedTrigger = trigger.startsWith("/") ? trigger : `/${trigger}`;
+  return COMMAND_TEMPLATES.find((c) => c.trigger === normalizedTrigger) || null;
+}
+function getCommandTemplatesByCategory(category) {
+  return COMMAND_TEMPLATES.filter((c) => c.category === category);
+}
+function getCommandTemplateIds() {
+  return COMMAND_TEMPLATES.map((c) => c.id);
+}
+function getCommandTriggers() {
+  return COMMAND_TEMPLATES.map((c) => c.trigger);
+}
+
+// src/profiles/manifest.ts
+var BUILTIN_PROFILES = [
+  {
+    name: "dev",
+    description: "Active development mode",
+    focus: "Implementation speed and working solutions",
+    behaviors: [
+      "Prefer working code over perfect code",
+      "Quick iterations with frequent testing",
+      "Minimize context switching",
+      "Focus on the current task"
+    ],
+    priorities: ["Functionality", "Simplicity", "Testability", "Speed"],
+    preferredTools: ["Edit", "Write", "Bash", "Read"],
+    injectedContext: `You are in DEVELOPMENT mode. Focus on:
+- Getting working code quickly
+- Writing minimal tests for new functionality
+- Keeping changes small and focused
+- Committing frequently`
+  },
+  {
+    name: "review",
+    description: "Code review mode",
+    focus: "Quality, security, and maintainability",
+    behaviors: [
+      "Thorough analysis before suggesting changes",
+      "Security-first mindset",
+      "Consider edge cases and failure modes",
+      "Provide constructive feedback"
+    ],
+    priorities: ["Security", "Code quality", "Best practices", "Maintainability"],
+    preferredTools: ["Read", "Grep", "Glob"],
+    avoidTools: ["Edit", "Write"],
+    injectedContext: `You are in REVIEW mode. Focus on:
+- Identifying potential bugs and security issues
+- Checking code against best practices
+- Verifying test coverage
+- Suggesting improvements without making changes`
+  },
+  {
+    name: "research",
+    description: "Exploration and discovery mode",
+    focus: "Understanding and analysis",
+    behaviors: [
+      "Deep exploration of codebase",
+      "Document findings thoroughly",
+      "Consider multiple approaches",
+      "Ask clarifying questions"
+    ],
+    priorities: ["Understanding", "Documentation", "Options analysis", "Learning"],
+    preferredTools: ["Read", "Grep", "Glob", "WebSearch", "WebFetch"],
+    avoidTools: ["Edit", "Write"],
+    injectedContext: `You are in RESEARCH mode. Focus on:
+- Understanding the codebase structure
+- Finding relevant documentation
+- Exploring different approaches
+- Creating summaries of findings`
+  },
+  {
+    name: "security",
+    description: "Security audit mode",
+    focus: "Vulnerability detection and hardening",
+    behaviors: [
+      "Assume hostile input",
+      "Check all authentication and authorization",
+      "Look for common vulnerability patterns",
+      "Verify encryption and data protection"
+    ],
+    priorities: ["Security", "Data protection", "Authentication", "Authorization"],
+    preferredTools: ["Read", "Grep", "Glob", "Bash"],
+    injectedContext: `You are in SECURITY AUDIT mode. Focus on:
+- OWASP Top 10 vulnerabilities
+- Authentication and authorization flaws
+- Data exposure risks
+- Injection vulnerabilities
+- Secrets and credentials in code`
+  }
+];
+var PROFILE_MANIFEST = {
+  version: 1,
+  profiles: BUILTIN_PROFILES
+};
+
+// src/profiles/index.ts
+function getBuiltinProfiles() {
+  return BUILTIN_PROFILES;
+}
+function getBuiltinProfile(name) {
+  return BUILTIN_PROFILES.find((p) => p.name === name) || null;
+}
+function getProfileNames() {
+  return BUILTIN_PROFILES.map((p) => p.name);
+}
+function isValidProfileName(name) {
+  return getProfileNames().includes(name);
+}
+function getProfileContext(name) {
+  const profile = getBuiltinProfile(name);
+  return profile?.injectedContext || null;
+}
+
+// src/guidelines/manifest.ts
+var BUILTIN_GUIDELINES = [
+  {
+    id: "security",
+    name: "Security Guidelines",
+    description: "Security best practices and vulnerability prevention",
+    category: "security",
+    priority: 10,
+    enabled: true,
+    scope: "global",
+    content: `## Security Guidelines
+
+### Input Validation
+- Validate all user input on the server side
+- Use allowlists over denylists when possible
+- Sanitize data before use in queries, commands, or output
+
+### Authentication & Authorization
+- Never store passwords in plain text
+- Use secure session management
+- Implement proper authorization checks on every endpoint
+- Use HTTPS for all communications
+
+### Data Protection
+- Encrypt sensitive data at rest and in transit
+- Never log sensitive information
+- Use environment variables for secrets
+- Implement proper access controls
+
+### Common Vulnerabilities to Prevent
+- SQL Injection: Use parameterized queries
+- XSS: Encode output, use CSP headers
+- CSRF: Use anti-CSRF tokens
+- Command Injection: Avoid shell commands with user input`
+  },
+  {
+    id: "code-style",
+    name: "Code Style Guidelines",
+    description: "Code formatting and style conventions",
+    category: "code-style",
+    priority: 7,
+    enabled: true,
+    scope: "global",
+    content: `## Code Style Guidelines
+
+### Naming Conventions
+- Use descriptive, meaningful names
+- camelCase for variables and functions
+- PascalCase for classes and types
+- SCREAMING_SNAKE_CASE for constants
+
+### Code Organization
+- One concept per file
+- Group related code together
+- Keep files under 300 lines when practical
+- Use barrel exports (index.ts) for public APIs
+
+### Functions
+- Single responsibility principle
+- Keep functions under 30 lines when practical
+- Use early returns to reduce nesting
+- Avoid side effects in pure functions
+
+### Comments
+- Don't comment obvious code
+- Explain "why" not "what"
+- Keep comments up to date
+- Use JSDoc for public APIs`
+  },
+  {
+    id: "testing",
+    name: "Testing Guidelines",
+    description: "Testing best practices and coverage requirements",
+    category: "testing",
+    priority: 8,
+    enabled: true,
+    scope: "global",
+    content: `## Testing Guidelines
+
+### Test Coverage
+- Aim for 80%+ code coverage
+- 100% coverage for critical paths
+- Don't sacrifice quality for coverage metrics
+
+### Test Structure
+- Arrange, Act, Assert (AAA) pattern
+- One concept per test
+- Descriptive test names that explain behavior
+- Independent tests (no shared state)
+
+### Test Types
+- Unit tests for business logic
+- Integration tests for component interactions
+- E2E tests for critical user flows
+
+### Test Quality
+- Tests should be deterministic
+- Fast execution (< 100ms for unit tests)
+- Easy to understand and maintain
+- Test behavior, not implementation`
+  },
+  {
+    id: "git",
+    name: "Git Workflow Guidelines",
+    description: "Version control best practices",
+    category: "git",
+    priority: 6,
+    enabled: true,
+    scope: "global",
+    content: `## Git Workflow Guidelines
+
+### Commits
+- Write clear, concise commit messages
+- Use conventional commits format
+- One logical change per commit
+- Don't commit generated files or secrets
+
+### Branches
+- Use feature branches
+- Keep branches short-lived
+- Delete branches after merge
+- Protect main/master branch
+
+### Pull Requests
+- Keep PRs focused and small
+- Write meaningful descriptions
+- Request reviews from appropriate people
+- Address all review comments
+
+### Commit Message Format
+\`\`\`
+<type>(<scope>): <description>
+
+[optional body]
+
+[optional footer]
+\`\`\`
+
+Types: feat, fix, docs, style, refactor, test, chore`
+  },
+  {
+    id: "performance",
+    name: "Performance Guidelines",
+    description: "Performance optimization best practices",
+    category: "performance",
+    priority: 5,
+    enabled: true,
+    scope: "global",
+    content: `## Performance Guidelines
+
+### General Principles
+- Measure before optimizing
+- Optimize critical paths first
+- Consider time/space tradeoffs
+- Profile in production-like environments
+
+### Database
+- Use indexes appropriately
+- Avoid N+1 queries
+- Paginate large result sets
+- Cache frequently accessed data
+
+### Frontend
+- Minimize bundle size
+- Lazy load when appropriate
+- Optimize images and assets
+- Use efficient rendering patterns
+
+### Backend
+- Use connection pooling
+- Implement appropriate caching
+- Async operations where beneficial
+- Monitor and alert on performance`
+  }
+];
+var GUIDELINE_MANIFEST = {
+  version: 1,
+  guidelines: BUILTIN_GUIDELINES
+};
+
+// src/guidelines/index.ts
+function getBuiltinGuidelines() {
+  return BUILTIN_GUIDELINES;
+}
+function getBuiltinGuideline(id) {
+  return BUILTIN_GUIDELINES.find((g) => g.id === id) || null;
+}
+function getGuidelinesByCategory(category) {
+  return BUILTIN_GUIDELINES.filter((g) => g.category === category);
+}
+function getGuidelineIds() {
+  return BUILTIN_GUIDELINES.map((g) => g.id);
+}
+function getGuidelineContent(id) {
+  const guideline = getBuiltinGuideline(id);
+  return guideline?.content || null;
+}
+function getEnabledGuidelines() {
+  return BUILTIN_GUIDELINES.filter((g) => g.enabled);
+}
+function getGuidelinesSortedByPriority() {
+  return [...BUILTIN_GUIDELINES].sort((a, b) => b.priority - a.priority);
+}
+
+// src/hooks/manifest.ts
+var HOOK_TEMPLATES = [
+  {
+    id: "typescript-check",
+    name: "TypeScript Type Check",
+    description: "Run TypeScript type checking before commits",
+    category: "quality",
+    event: "commit:pre",
+    command: "npx tsc --noEmit",
+    timeout: 6e4,
+    blocking: true
+  },
+  {
+    id: "eslint-check",
+    name: "ESLint Check",
+    description: "Run ESLint on staged files before commits",
+    category: "quality",
+    event: "commit:pre",
+    command: 'files=$(git diff --cached --name-only --diff-filter=d | grep -E "\\.(js|ts|jsx|tsx)$"); [ -z "$files" ] || npx eslint --fix $files',
+    timeout: 6e4,
+    blocking: true
+  },
+  {
+    id: "prettier-format",
+    name: "Prettier Format",
+    description: "Format staged files with Prettier before commits",
+    category: "quality",
+    event: "commit:pre",
+    command: "npx prettier --write $(git diff --cached --name-only --diff-filter=d)",
+    timeout: 3e4,
+    blocking: false
+  },
+  {
+    id: "test-on-save",
+    name: "Run Tests on Save",
+    description: "Run related tests when test files are saved",
+    category: "quality",
+    event: "file:save",
+    matcher: "**/*.test.{ts,tsx,js,jsx}",
+    command: "npx vitest run {{file}}",
+    timeout: 12e4,
+    blocking: false
+  },
+  {
+    id: "security-scan",
+    name: "Security Scan",
+    description: "Scan for security vulnerabilities before commits",
+    category: "security",
+    event: "commit:pre",
+    command: "npm audit --audit-level=high",
+    timeout: 6e4,
+    blocking: true
+  },
+  {
+    id: "secret-detection",
+    name: "Secret Detection",
+    description: "Detect secrets in staged files before commits",
+    category: "security",
+    event: "commit:pre",
+    command: 'files=$(git diff --cached --name-only --diff-filter=d); [ -z "$files" ] || npx secretlint $files',
+    timeout: 3e4,
+    blocking: true
+  },
+  {
+    id: "build-check",
+    name: "Build Check",
+    description: "Verify build succeeds before commits",
+    category: "quality",
+    event: "commit:pre",
+    command: "npm run build",
+    timeout: 3e5,
+    blocking: true
+  },
+  {
+    id: "session-summary",
+    name: "Session Summary",
+    description: "Generate session summary on session end",
+    category: "productivity",
+    event: "session:end",
+    command: 'echo "Session ended at $(date)" >> ~/.skillkit/sessions/$(date +%Y-%m-%d).log',
+    timeout: 5e3,
+    blocking: false
+  },
+  {
+    id: "auto-commit-message",
+    name: "Auto Commit Message",
+    description: "Generate conventional commit message",
+    category: "workflow",
+    event: "commit:pre",
+    command: "git diff --cached --stat",
+    timeout: 5e3,
+    blocking: false
+  },
+  {
+    id: "notify-build-fail",
+    name: "Build Failure Notification",
+    description: "Notify on build failure",
+    category: "workflow",
+    event: "build:fail",
+    command: 'echo "Build failed at $(date)" | tee -a ~/.skillkit/build.log',
+    timeout: 5e3,
+    blocking: false
+  },
+  {
+    id: "test-coverage-check",
+    name: "Test Coverage Check",
+    description: "Verify test coverage meets threshold before commits",
+    category: "quality",
+    event: "commit:pre",
+    command: `npm test -- --coverage --coverageThreshold='{"global":{"statements":80}}'`,
+    timeout: 18e4,
+    blocking: true
+  },
+  {
+    id: "dependency-check",
+    name: "Dependency Check",
+    description: "Check for outdated dependencies on session start",
+    category: "productivity",
+    event: "session:start",
+    command: "npm outdated || true",
+    timeout: 3e4,
+    blocking: false
+  }
+];
+var HOOK_TEMPLATE_MANIFEST = {
+  version: 1,
+  templates: HOOK_TEMPLATES
+};
+
+// src/hooks/index.ts
+function getHookTemplates() {
+  return HOOK_TEMPLATES;
+}
+function getHookTemplate(id) {
+  return HOOK_TEMPLATES.find((t) => t.id === id) || null;
+}
+function getHookTemplatesByCategory(category) {
+  return HOOK_TEMPLATES.filter((t) => t.category === category);
+}
+function getHookTemplatesByEvent(event) {
+  return HOOK_TEMPLATES.filter((t) => t.event === event);
+}
+function getHookTemplateIds() {
+  return HOOK_TEMPLATES.map((t) => t.id);
+}
+function formatHookCommand(template, variables) {
+  let command = template.command;
+  const vars = { ...template.variables, ...variables };
+  for (const [key, value] of Object.entries(vars)) {
+    command = command.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value);
+  }
+  return command;
+}
+
+// src/index.ts
+var RESOURCES_VERSION = "2.0.0";
+export {
+  AGENT_MANIFEST,
+  BUILTIN_GUIDELINES,
+  BUILTIN_PROFILES,
+  BUNDLED_AGENTS,
+  COMMAND_MANIFEST,
+  COMMAND_TEMPLATES,
+  GUIDELINE_MANIFEST,
+  HOOK_TEMPLATES,
+  HOOK_TEMPLATE_MANIFEST,
+  PROFILE_MANIFEST,
+  RESOURCES_VERSION,
+  formatHookCommand,
+  getAgentTemplate,
+  getAvailableAgents,
+  getBuiltinGuideline,
+  getBuiltinGuidelines,
+  getBuiltinProfile,
+  getBuiltinProfiles,
+  getBundledAgent,
+  getBundledAgentIds,
+  getBundledAgents,
+  getBundledAgentsByCategory,
+  getCommandByTrigger,
+  getCommandTemplate,
+  getCommandTemplateIds,
+  getCommandTemplates,
+  getCommandTemplatesByCategory,
+  getCommandTriggers,
+  getEnabledGuidelines,
+  getGuidelineContent,
+  getGuidelineIds,
+  getGuidelinesByCategory,
+  getGuidelinesSortedByPriority,
+  getHookTemplate,
+  getHookTemplateIds,
+  getHookTemplates,
+  getHookTemplatesByCategory,
+  getHookTemplatesByEvent,
+  getInstalledAgentIds,
+  getProfileContext,
+  getProfileNames,
+  installBundledAgent,
+  isAgentInstalled,
+  isValidProfileName
+};
+//# sourceMappingURL=index.js.map