devskill 2.0.8 → 2.0.10

package/meta.ts

@@ -4,6 +4,16 @@ export interface VendorSkillMeta {
   skills?: Record<string, string> // sourceSkillName -> outputSkillName. If omitted, auto-discovers all subdirectories.
 }
 
+export interface RuleMeta {
+  file: string // path relative to repo root, e.g. 'rules/vue-style.md'
+  description?: string
+}
+
+export interface WorkflowMeta {
+  file: string // path relative to repo root, e.g. 'workflows/git-flow.md'
+  description?: string
+}
+
 /**
  * Repositories to clone as submodules and generate skills from their docs.
  * After cloning, read docs and generate skills manually into skills/{name}/
@@ -134,7 +144,8 @@ export const collections: Record<string, string[]> = {
     'pinia-options',
     'builderx_spa-api',
     'builderx_spa-permission',
-    'builderx_spa-design'
+    'builderx_spa-design',
+    'git-commit',
   ],
   'builderx_api': [
     'builderx_api-schemas',
@@ -144,5 +155,43 @@ export const collections: Record<string, string[]> = {
     'builderx_api-redis',
     'builderx_api-rabbitmq',
     'builderx_api-mongodb',
+    'git-commit',
   ]
 }
+
+/**
+ * Individual rule files (markdown) to install into AI tool rule directories.
+ * Format: { 'rule-name': { file: 'rules/rule-name.md', description: '...' } }
+ */
+export const rules: Record<string, RuleMeta> = {
+  'vue-style': {
+    file: 'rules/vue-style.md',
+    description: 'Vue 3 coding style and conventions',
+  },
+  'typescript-strict': {
+    file: 'rules/typescript-strict.md',
+    description: 'Strict TypeScript conventions',
+  },
+}
+
+/**
+ * Individual workflow files (markdown) to install into AI tool workflow directories.
+ * Format: { 'workflow-name': { file: 'workflows/workflow-name.md', description: '...' } }
+ */
+export const workflows: Record<string, WorkflowMeta> = {
+  'git-flow': {
+    file: 'workflows/git-flow.md',
+    description: 'Feature branch git workflow',
+  },
+}
+
+/**
+ * Grouped collections of rules + workflows per project.
+ * Use `npm start rules` or `npm start workflows` to install a batch.
+ */
+export const ruleCollections: Record<string, { rules?: string[], workflows?: string[] }> = {
+  'builderx_spa': {
+    rules: ['vue-style', 'typescript-strict'],
+    workflows: ['git-flow'],
+  },
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devskill",
-  "version": "2.0.8",
+  "version": "2.0.10",
   "description": "Equip Cursor, Windsurf, Cline, Antigravity, Claude Code, Codex, GitHub Copilot and other AI Agents with expert programming superpowers via a single interactive prompt.",
   "homepage": "https://vskill.vercel.app",
   "repository": {

package/rules/typescript-strict.md

@@ -0,0 +1,30 @@
+# TypeScript Strict Rules
+
+## Strict Mode
+- Always enable `"strict": true` in `tsconfig.json`
+- No implicit `any` — always type function parameters
+- Use `unknown` instead of `any` when type is uncertain
+
+## Types vs Interfaces
+- Use `interface` for object shapes that may be extended
+- Use `type` for unions, intersections, and computed types
+
+```ts
+// Good: interface for extendable shapes
+interface User {
+  id: string
+  name: string
+}
+
+// Good: type for unions
+type Status = 'active' | 'inactive' | 'pending'
+```
+
+## Null Handling
+- Use optional chaining `?.` and nullish coalescing `??`
+- Avoid non-null assertion `!` — handle null explicitly
+- Prefer explicit return types on exported functions
+
+## Generics
+- Name generics descriptively: `TItem`, `TKey`, `TResponse`
+- Constrain generics when possible: `<T extends object>`

package/rules/vue-style.md

@@ -0,0 +1,35 @@
+# Vue Style Rules
+
+## Component Naming
+- Use PascalCase for component names: `MyComponent.vue`
+- Use kebab-case in templates: `<my-component />`
+- Prefix base/generic components with `Base`: `BaseButton`, `BaseInput`
+
+## Script Setup
+- Always use `<script setup lang="ts">` for Vue 3 components
+- Use `defineProps` and `defineEmits` with TypeScript generics
+- Define props interface separately for reusability
+
+```vue
+<script setup lang="ts">
+interface Props {
+  title: string
+  count?: number
+}
+const props = defineProps<Props>()
+const emit = defineEmits<{
+  change: [value: number]
+  submit: []
+}>()
+</script>
+```
+
+## Template
+- Use `v-bind` shorthand `:` and `v-on` shorthand `@`
+- Prefer `v-show` for frequent toggles, `v-if` for conditional rendering
+- Always provide `key` when using `v-for`
+
+## Composables
+- Prefix with `use`: `useAuth`, `useCart`
+- Always return reactive refs explicitly
+- Keep side effects inside `onMounted` / `watchEffect`

package/scripts/cli.ts

@@ -5,7 +5,7 @@ import process from 'node:process'
 import { fileURLToPath } from 'node:url'
 import * as p from '@clack/prompts'
 import prompts from 'prompts'
-import { collections, manual, submodules, vendors } from '../meta.ts'
+import { collections, manual, ruleCollections, rules, submodules, vendors, workflows } from '../meta.ts'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const root = join(__dirname, '..')
@@ -389,14 +389,40 @@ async function cleanup(skipPrompt = false) {
   }
 }
 
-async function installSkills(targetCollectionNames: string[] = []) {
-  const spinner = p.spinner()
-
+function getAllCollections(): Record<string, string[]> {
   const allCollections: Record<string, string[]> = { ...collections }
   for (const [vendorName, config] of Object.entries(vendors)) {
     const vendorConfig = config as VendorConfig
-    allCollections[vendorName] = Object.values(vendorConfig.skills)
+    let vendorSkills: string[] = []
+    
+    if (vendorConfig.skills && Object.keys(vendorConfig.skills).length > 0) {
+      vendorSkills = Object.values(vendorConfig.skills)
+    } else {
+      const vendorPath = join(root, 'vendor', vendorName)
+      const vendorSkillsPath = join(vendorPath, 'skills')
+      const searchPath = existsSync(vendorSkillsPath) ? vendorSkillsPath : (existsSync(vendorPath) ? vendorPath : null)
+      
+      if (searchPath) {
+        const entries = readdirSync(searchPath, { withFileTypes: true })
+        for (const entry of entries) {
+          if (entry.isDirectory() && !entry.name.startsWith('.')) {
+            vendorSkills.push(entry.name)
+          }
+        }
+      }
+    }
+    
+    if (vendorSkills.length > 0) {
+      allCollections[vendorName] = vendorSkills
+    }
   }
+  return allCollections
+}
+
+async function installSkills(targetCollectionNames: string[] = []) {
+  const spinner = p.spinner()
+
+  const allCollections = getAllCollections()
 
   if (Object.keys(allCollections).length === 0) {
     p.log.warn('No collections or vendors defined in meta.ts')
@@ -661,32 +687,7 @@ async function findSkills(query?: string) {
   const allSkills = getExistingSkillNames()
   p.intro(`Search results for ${query ? `"${query}"` : 'all'}`)
   
-  const allCollections: Record<string, string[]> = { ...collections }
-  for (const [vendorName, config] of Object.entries(vendors)) {
-    const vendorConfig = config as VendorConfig
-    let vendorSkills: string[] = []
-    
-    if (vendorConfig.skills && Object.keys(vendorConfig.skills).length > 0) {
-      vendorSkills = Object.values(vendorConfig.skills)
-    } else {
-      const vendorPath = join(root, 'vendor', vendorName)
-      const vendorSkillsPath = join(vendorPath, 'skills')
-      const searchPath = existsSync(vendorSkillsPath) ? vendorSkillsPath : (existsSync(vendorPath) ? vendorPath : null)
-      
-      if (searchPath) {
-        const entries = readdirSync(searchPath, { withFileTypes: true })
-        for (const entry of entries) {
-          if (entry.isDirectory() && !entry.name.startsWith('.')) {
-            vendorSkills.push(entry.name)
-          }
-        }
-      }
-    }
-    
-    if (vendorSkills.length > 0) {
-      allCollections[vendorName] = vendorSkills
-    }
-  }
+  const allCollections = getAllCollections()
 
   let q = ''
   if (!query) {
@@ -725,7 +726,242 @@ async function findSkills(query?: string) {
   }
 }
 
+// ─── Rules & Workflows ────────────────────────────────────────────────────────
+
+function getExistingRuleNames(): string[] {
+  return Object.keys(rules)
+}
+
+function getExistingWorkflowNames(): string[] {
+  return Object.keys(workflows)
+}
+
+async function installRules(targetRuleNames: string[] = []) {
+  const spinner = p.spinner()
+
+  const allRules = getExistingRuleNames()
+  if (allRules.length === 0) {
+    p.log.warn('No rules defined in meta.ts')
+    return
+  }
+
+  let selectedRules: string[] = []
+
+  if (targetRuleNames.length > 0) {
+    const invalid = targetRuleNames.filter(n => !allRules.includes(n))
+    if (invalid.length > 0) {
+      p.log.error(`Rules not found: ${invalid.join(', ')}`)
+      return
+    }
+    selectedRules = targetRuleNames
+  }
+  else {
+    const response = await prompts({
+      type: 'autocompleteMultiselect',
+      name: 'selected',
+      message: 'Select rules to install (Space to select, Enter to confirm)',
+      choices: allRules.map(name => ({
+        title: name,
+        value: name,
+        description: rules[name].description ?? '',
+      })),
+    })
+    if (!response.selected || response.selected.length === 0) {
+      p.log.warn('No rules selected (or canceled)')
+      return
+    }
+    selectedRules = response.selected
+  }
+
+  const targetProject = await p.text({
+    message: 'Enter target project directory path',
+    initialValue: process.cwd(),
+    placeholder: process.cwd(),
+    validate: value => {
+      if (!value) return 'Path is required'
+      if (!existsSync(value)) return 'Directory does not exist'
+    },
+  })
+  if (p.isCancel(targetProject)) { p.cancel('Cancelled'); return }
+
+  const toolChoice = await p.select({
+    message: 'Which AI tool are you installing rules for?',
+    options: [
+      { value: '.cursor/rules', label: 'Cursor (.cursor/rules/)' },
+      { value: '.windsurf/rules', label: 'Windsurf (.windsurf/rules/)' },
+      { value: '.claude', label: 'Claude Code (.claude/)' },
+      { value: '.agents/rules', label: 'Antigravity (.agents/rules/)' },
+      { value: 'rules', label: 'Generic (rules/)' },
+      { value: 'custom', label: 'Custom path...' },
+    ],
+  })
+  if (p.isCancel(toolChoice)) { p.cancel('Cancelled'); return }
+
+  let rulesDirName = toolChoice as string
+  if (toolChoice === 'custom') {
+    const customDir = await p.text({ message: 'Enter custom path:', initialValue: 'rules', placeholder: 'rules' })
+    if (p.isCancel(customDir)) { p.cancel('Cancelled'); return }
+    rulesDirName = customDir as string
+  }
+
+  const targetDir = join(targetProject as string, rulesDirName)
+  if (!existsSync(targetDir)) mkdirSync(targetDir, { recursive: true })
+
+  spinner.start(`Installing ${selectedRules.length} rule(s) to ${targetDir}...`)
+  let successCount = 0
+  for (const ruleName of selectedRules) {
+    const meta = rules[ruleName]
+    const srcFile = join(root, meta.file)
+    if (!existsSync(srcFile)) {
+      p.log.warn(`Rule file not found: ${meta.file}`)
+      continue
+    }
+    const destFile = join(targetDir, `${ruleName}.md`)
+    cpSync(srcFile, destFile)
+    successCount++
+  }
+  spinner.stop(`Installed ${successCount}/${selectedRules.length} rule(s)`)
+}
+
+async function installWorkflows(targetWorkflowNames: string[] = []) {
+  const spinner = p.spinner()
+
+  const allWorkflows = getExistingWorkflowNames()
+  if (allWorkflows.length === 0) {
+    p.log.warn('No workflows defined in meta.ts')
+    return
+  }
+
+  let selectedWorkflows: string[] = []
+
+  if (targetWorkflowNames.length > 0) {
+    const invalid = targetWorkflowNames.filter(n => !allWorkflows.includes(n))
+    if (invalid.length > 0) {
+      p.log.error(`Workflows not found: ${invalid.join(', ')}`)
+      return
+    }
+    selectedWorkflows = targetWorkflowNames
+  }
+  else {
+    const response = await prompts({
+      type: 'autocompleteMultiselect',
+      name: 'selected',
+      message: 'Select workflows to install (Space to select, Enter to confirm)',
+      choices: allWorkflows.map(name => ({
+        title: name,
+        value: name,
+        description: workflows[name].description ?? '',
+      })),
+    })
+    if (!response.selected || response.selected.length === 0) {
+      p.log.warn('No workflows selected (or canceled)')
+      return
+    }
+    selectedWorkflows = response.selected
+  }
+
+  const targetProject = await p.text({
+    message: 'Enter target project directory path',
+    initialValue: process.cwd(),
+    placeholder: process.cwd(),
+    validate: value => {
+      if (!value) return 'Path is required'
+      if (!existsSync(value)) return 'Directory does not exist'
+    },
+  })
+  if (p.isCancel(targetProject)) { p.cancel('Cancelled'); return }
+
+  const toolChoice = await p.select({
+    message: 'Which AI tool are you installing workflows for?',
+    options: [
+      { value: '.agents/workflows', label: 'Antigravity (.agents/workflows/)' },
+      { value: '.cursor/workflows', label: 'Cursor (.cursor/workflows/)' },
+      { value: '.windsurf/workflows', label: 'Windsurf (.windsurf/workflows/)' },
+      { value: '.claude/workflows', label: 'Claude Code (.claude/workflows/)' },
+      { value: 'workflows', label: 'Generic (workflows/)' },
+      { value: 'custom', label: 'Custom path...' },
+    ],
+  })
+  if (p.isCancel(toolChoice)) { p.cancel('Cancelled'); return }
+
+  let workflowsDirName = toolChoice as string
+  if (toolChoice === 'custom') {
+    const customDir = await p.text({ message: 'Enter custom path:', initialValue: 'workflows', placeholder: 'workflows' })
+    if (p.isCancel(customDir)) { p.cancel('Cancelled'); return }
+    workflowsDirName = customDir as string
+  }
+
+  const targetDir = join(targetProject as string, workflowsDirName)
+  if (!existsSync(targetDir)) mkdirSync(targetDir, { recursive: true })
+
+  spinner.start(`Installing ${selectedWorkflows.length} workflow(s) to ${targetDir}...`)
+  let successCount = 0
+  for (const workflowName of selectedWorkflows) {
+    const meta = workflows[workflowName]
+    const srcFile = join(root, meta.file)
+    if (!existsSync(srcFile)) {
+      p.log.warn(`Workflow file not found: ${meta.file}`)
+      continue
+    }
+    const destFile = join(targetDir, `${workflowName}.md`)
+    cpSync(srcFile, destFile)
+    successCount++
+  }
+  spinner.stop(`Installed ${successCount}/${selectedWorkflows.length} workflow(s)`)
+}
+
+async function findRulesAndWorkflows(query?: string) {
+  p.intro(`Search results for ${query ? `"${query}"` : 'all'}`)
+
+  let q = ''
+  if (!query) {
+    const userInput = await p.text({
+      message: 'Enter keyword to search (leave empty to list all):',
+      placeholder: 'e.g. vue',
+    })
+    if (p.isCancel(userInput)) { p.cancel('Cancelled'); return }
+    q = (userInput as string).toLowerCase()
+  }
+  else {
+    q = query.toLowerCase()
+  }
+
+  const matchedRuleCollections = Object.keys(ruleCollections).filter(c => c.toLowerCase().includes(q))
+  if (matchedRuleCollections.length > 0) {
+    p.log.success('📦 Rule Collections found:')
+    for (const c of matchedRuleCollections) {
+      const col = ruleCollections[c]
+      const rulesCount = col.rules?.length ?? 0
+      const wfCount = col.workflows?.length ?? 0
+      p.log.message(`  - ${c} (${rulesCount} rules, ${wfCount} workflows)`)
+    }
+  }
+
+  const matchedRules = Object.keys(rules).filter(r => r.toLowerCase().includes(q))
+  if (matchedRules.length > 0) {
+    p.log.success('📋 Rules found:')
+    for (const r of matchedRules) {
+      p.log.message(`  - ${r}: ${rules[r].description ?? ''} -> \`npx devskill rules ${r}\``)
+    }
+  }
+  else if (q) {
+    p.log.warn('No rules found matching query')
+  }
+
+  const matchedWorkflows = Object.keys(workflows).filter(w => w.toLowerCase().includes(q))
+  if (matchedWorkflows.length > 0) {
+    p.log.success('⚙️  Workflows found:')
+    for (const w of matchedWorkflows) {
+      p.log.message(`  - ${w}: ${workflows[w].description ?? ''} -> \`npx devskill workflows ${w}\``)
+    }
+  }
+  else if (q) {
+    p.log.warn('No workflows found matching query')
+  }
+}
+
 async function main() {
+
   const args = process.argv.slice(2)
   const skipPrompt = args.includes('-y') || args.includes('--yes')
   
@@ -784,9 +1020,31 @@ async function main() {
     return
   }
 
+  if (command === 'rules') {
+    const namesJoined = targetNames.length > 0 ? ` (${targetNames.join(', ')})` : ''
+    p.intro(`Skills Manager - Rules${namesJoined}`)
+    await installRules(targetNames)
+    p.outro('Done')
+    return
+  }
+
+  if (command === 'workflows') {
+    const namesJoined = targetNames.length > 0 ? ` (${targetNames.join(', ')})` : ''
+    p.intro(`Skills Manager - Workflows${namesJoined}`)
+    await installWorkflows(targetNames)
+    p.outro('Done')
+    return
+  }
+
+  if (command === 'find-rules') {
+    await findRulesAndWorkflows(targetName)
+    p.outro('Done')
+    return
+  }
+
   if (skipPrompt) {
     p.log.error('Command required when using -y flag')
-    p.log.info('Available commands: find, install, add, init, sync, check, cleanup')
+    p.log.info('Available commands: find, install, add, rules, workflows, find-rules, init, sync, check, cleanup')
     process.exit(1)
   }
 
@@ -795,10 +1053,13 @@ async function main() {
   const action = await p.select({
     message: 'What would you like to do?',
     options: [
-      { value: 'install', label: 'Install collections', hint: 'Copy entire skill collections to a local project' },
+      { value: 'install', label: 'Install skill collections', hint: 'Copy entire skill collections to a local project' },
       { value: 'add', label: 'Add specific skills', hint: 'Choose individual skills to add to your project' },
       { value: 'find', label: 'Find a skill or collection', hint: 'Search by keyword' },
-      { value: 'sync', label: 'Sync submodules', hint: 'Pull latest and sync Type 2 skills' },
+      { value: 'rules', label: 'Install rules', hint: 'Copy rule files to your AI tool rules directory' },
+      { value: 'workflows', label: 'Install workflows', hint: 'Copy workflow files to your AI tool workflows directory' },
+      { value: 'find-rules', label: 'Find rules or workflows', hint: 'Search rules/workflows by keyword' },
+      { value: 'sync', label: 'Sync submodules', hint: 'Pull latest and sync vendor skills' },
       { value: 'init', label: 'Init submodules', hint: 'Add new submodules from meta.ts' },
       { value: 'check', label: 'Check updates', hint: 'See available updates' },
       { value: 'cleanup', label: 'Cleanup', hint: 'Remove skills not listed in meta.ts' },
@@ -832,6 +1093,15 @@ async function main() {
     case 'cleanup':
       await cleanup()
       break
+    case 'rules':
+      await installRules()
+      break
+    case 'workflows':
+      await installWorkflows()
+      break
+    case 'find-rules':
+      await findRulesAndWorkflows()
+      break
   }
 
   p.outro('Done')

package/workflows/git-flow.md

@@ -0,0 +1,52 @@
+---
+description: Feature branch git workflow
+---
+
+## Creating a Feature Branch
+
+1. Ensure you are on the latest `main` branch:
+```bash
+git checkout main
+git pull origin main
+```
+
+2. Create and checkout a new feature branch:
+```bash
+git checkout -b feature/<ticket-id>-short-description
+# Example: feature/BX-123-add-user-login
+```
+
+## During Development
+
+3. Commit frequently with meaningful messages following Conventional Commits:
+```
+feat: add login form validation
+fix: handle empty email edge case
+chore: update dependencies
+```
+
+4. Push branch to remote regularly:
+```bash
+git push origin feature/<branch-name>
+```
+
+## Creating a Pull Request
+
+5. Rebase on `main` before opening a PR to keep history clean:
+```bash
+git fetch origin
+git rebase origin/main
+```
+
+6. Open a Pull Request with:
+   - Title matching the ticket: `feat: BX-123 Add user login`
+   - Description of changes and testing steps
+   - Link to the ticket/issue
+
+## After Merge
+
+7. Delete the feature branch locally and remotely:
+```bash
+git branch -d feature/<branch-name>
+git push origin --delete feature/<branch-name>
+```