cognova 0.2.0 → 0.2.2

package/server/drizzle/migrations/meta/_journal.json

@@ -85,6 +85,20 @@
       "when": 1771384095170,
       "tag": "0011_tearful_johnny_storm",
       "breakpoints": true
+    },
+    {
+      "idx": 12,
+      "version": "7",
+      "when": 1771472797273,
+      "tag": "0012_good_deadpool",
+      "breakpoints": true
+    },
+    {
+      "idx": 13,
+      "version": "7",
+      "when": 1771518918468,
+      "tag": "0013_swift_snowbird",
+      "breakpoints": true
     }
   ]
 }

package/server/middleware/auth.ts

@@ -33,7 +33,6 @@ async function checkApiToken(event: H3Event): Promise<boolean> {
 
 export default defineEventHandler(async (event) => {
   const path = getRequestURL(event).pathname
-
   // Skip auth for root path (public home page)
   if (path === '/') return
 

package/server/plugins/05.skills-catalog.ts

@@ -0,0 +1,105 @@
+import { eq } from 'drizzle-orm'
+import { waitForDb } from '~~/server/utils/db-state'
+import { getDb } from '~~/server/db'
+import * as schema from '~~/server/db/schema'
+
+const REGISTRY_URL = 'https://raw.githubusercontent.com/Patrity/cognova-skills/main/registry.json'
+const SYNC_INTERVAL_MS = 30 * 60 * 1000 // 30 minutes
+
+interface RegistryEntry {
+  name: string
+  description: string
+  version: string
+  author: string
+  tags: string[]
+  requiresSecrets: string[]
+  files: string[]
+  updatedAt: string
+}
+
+async function syncRegistry() {
+  try {
+    const response = await fetch(REGISTRY_URL)
+    if (!response.ok) {
+      console.warn(`[skills-catalog] Failed to fetch registry: ${response.status}`)
+      return
+    }
+
+    const entries: RegistryEntry[] = await response.json()
+    if (!Array.isArray(entries)) {
+      console.warn('[skills-catalog] Invalid registry format')
+      return
+    }
+
+    const db = getDb()
+    const now = new Date()
+
+    for (const entry of entries) {
+      if (!entry.name || !entry.description || !entry.version) continue
+
+      await db.insert(schema.skillsCatalog)
+        .values({
+          name: entry.name,
+          description: entry.description,
+          version: entry.version,
+          author: entry.author || '',
+          tags: entry.tags || [],
+          requiresSecrets: entry.requiresSecrets || [],
+          files: entry.files || [],
+          updatedAt: new Date(entry.updatedAt || now),
+          syncedAt: now
+        })
+        .onConflictDoUpdate({
+          target: schema.skillsCatalog.name,
+          set: {
+            description: entry.description,
+            version: entry.version,
+            author: entry.author || '',
+            tags: entry.tags || [],
+            requiresSecrets: entry.requiresSecrets || [],
+            files: entry.files || [],
+            updatedAt: new Date(entry.updatedAt || now),
+            syncedAt: now
+          }
+        })
+    }
+
+    // Remove skills no longer in registry
+    const catalogItems = await db.query.skillsCatalog.findMany()
+    const registryNames = new Set(entries.map(e => e.name))
+    for (const item of catalogItems) {
+      if (!registryNames.has(item.name)) {
+        await db.delete(schema.skillsCatalog)
+          .where(eq(schema.skillsCatalog.id, item.id))
+      }
+    }
+
+    console.log(`[skills-catalog] Synced ${entries.length} skills from registry`)
+  } catch (error) {
+    console.warn('[skills-catalog] Registry sync failed:', error)
+  }
+}
+
+let syncTimer: ReturnType<typeof setInterval> | null = null
+
+export default defineNitroPlugin(async (nitroApp) => {
+  const dbAvailable = await waitForDb(10000)
+  if (!dbAvailable) {
+    console.log('[skills-catalog] Database not available, skipping')
+    return
+  }
+
+  // Initial sync after a short delay
+  setTimeout(() => syncRegistry(), 10000)
+
+  // Periodic sync
+  syncTimer = setInterval(() => syncRegistry(), SYNC_INTERVAL_MS)
+
+  nitroApp.hooks.hook('close', () => {
+    if (syncTimer) {
+      clearInterval(syncTimer)
+      syncTimer = null
+    }
+    console.log('[skills-catalog] Cleanup complete')
+  })
+})

package/server/utils/skills-path.ts

@@ -0,0 +1,197 @@
+import { homedir } from 'os'
+import { join } from 'path'
+import type { SkillMeta, SkillFile } from '~~/shared/types'
+
+const CORE_SKILLS = ['memory', 'task', 'project', 'secret', 'environment']
+
+export function getSkillsDir(): string {
+  return join(homedir(), '.claude', 'skills')
+}
+
+export function getInactiveSkillsDir(): string {
+  return join(homedir(), '.claude', 'inactive-skills')
+}
+
+export function getSkillPath(name: string, active: boolean = true): string {
+  const base = active ? getSkillsDir() : getInactiveSkillsDir()
+  return join(base, name)
+}
+
+export function isCoreSkill(name: string): boolean {
+  return CORE_SKILLS.includes(name)
+}
+
+/**
+ * Parse SKILL.md YAML frontmatter into SkillMeta.
+ * Handles both top-level and metadata-nested custom fields.
+ */
+export function parseSkillFrontmatter(content: string): SkillMeta {
+  const defaults: SkillMeta = {
+    name: '',
+    description: '',
+    version: '',
+    author: '',
+    tags: [],
+    allowedTools: [],
+    requiresSecrets: [],
+    repository: '',
+    installedFrom: '',
+    disableModelInvocation: false,
+    userInvocable: true,
+    context: '',
+    agent: ''
+  }
+
+  const match = content.match(/^---\n([\s\S]*?)\n---/)
+  if (!match?.[1]) return defaults
+
+  const yaml = match[1]
+  const result = { ...defaults }
+
+  // Simple YAML parser for flat + one-level nested keys
+  let inMetadata = false
+  for (const line of yaml.split('\n')) {
+    // Check for metadata block
+    if (line === 'metadata:') {
+      inMetadata = true
+      continue
+    }
+
+    // Nested under metadata (indented)
+    if (inMetadata && /^\s{2}\S/.test(line)) {
+      const nested = line.trim()
+      const colonIdx = nested.indexOf(':')
+      if (colonIdx === -1) continue
+      const key = nested.slice(0, colonIdx).trim()
+      const val = nested.slice(colonIdx + 1).trim()
+      assignMetaField(result, key, val)
+      continue
+    }
+
+    // End of metadata block if we hit a non-indented line
+    if (inMetadata && /^\S/.test(line))
+      inMetadata = false
+
+    // Top-level key
+    const colonIdx = line.indexOf(':')
+    if (colonIdx === -1) continue
+    const key = line.slice(0, colonIdx).trim()
+    const val = line.slice(colonIdx + 1).trim()
+    assignTopLevelField(result, key, val)
+  }
+
+  return result
+}
+
+function assignTopLevelField(result: SkillMeta, key: string, val: string): void {
+  switch (key) {
+    case 'name':
+      result.name = unquote(val)
+      break
+    case 'description':
+      result.description = unquote(val)
+      break
+    case 'allowed-tools':
+      result.allowedTools = val.split(',').map(s => s.trim()).filter(Boolean)
+      break
+    case 'disable-model-invocation':
+      result.disableModelInvocation = val === 'true'
+      break
+    case 'user-invocable':
+      result.userInvocable = val !== 'false'
+      break
+    case 'context':
+      result.context = unquote(val)
+      break
+    case 'agent':
+      result.agent = unquote(val)
+      break
+  }
+}
+
+function assignMetaField(result: SkillMeta, key: string, val: string): void {
+  switch (key) {
+    case 'version':
+      result.version = unquote(val)
+      break
+    case 'author':
+      result.author = unquote(val)
+      break
+    case 'tags':
+      result.tags = parseYamlArray(val)
+      break
+    case 'requires-secrets':
+      result.requiresSecrets = parseYamlArray(val)
+      break
+    case 'repository':
+      result.repository = unquote(val)
+      break
+    case 'installed-from':
+      result.installedFrom = unquote(val)
+      break
+  }
+}
+
+function unquote(s: string): string {
+  if ((s.startsWith('"') && s.endsWith('"'))
+    || (s.startsWith('\'') && s.endsWith('\'')))
+    return s.slice(1, -1)
+  return s
+}
+
+function parseYamlArray(val: string): string[] {
+  // Handle inline array: ["key1", "key2"] or [key1, key2]
+  if (val.startsWith('[') && val.endsWith(']')) {
+    const inner = val.slice(1, -1).trim()
+    if (!inner) return []
+    return inner.split(',').map(s => unquote(s.trim())).filter(Boolean)
+  }
+  return []
+}
+
+/**
+ * Build a file tree for a skill directory.
+ * Excludes __pycache__ and .pyc files.
+ */
+export async function buildSkillFileTree(dirPath: string): Promise<SkillFile[]> {
+  const { readdir, stat } = await import('fs/promises')
+  const entries = await readdir(dirPath).catch(() => [])
+  const files: SkillFile[] = []
+
+  for (const entry of entries) {
+    if (entry === '__pycache__' || entry.endsWith('.pyc'))
+      continue
+
+    const fullPath = join(dirPath, entry)
+    const stats = await stat(fullPath).catch(() => null)
+    if (!stats) continue
+
+    if (stats.isDirectory()) {
+      const children = await buildSkillFileTree(fullPath)
+      files.push({ name: entry, path: entry, type: 'directory', children })
+    } else {
+      files.push({ name: entry, path: entry, type: 'file' })
+    }
+  }
+
+  // Sort: directories first, then alphabetical
+  files.sort((a, b) => {
+    if (a.type !== b.type) return a.type === 'directory' ? -1 : 1
+    return a.name.localeCompare(b.name)
+  })
+
+  return files
+}
+
+/**
+ * Validate a skill name for filesystem safety.
+ */
+export function validateSkillName(name: string): string | null {
+  if (!name || name.length > 64)
+    return 'Name must be 1-64 characters'
+  if (!/^[a-z0-9][a-z0-9_-]*$/.test(name))
+    return 'Name must start with a letter/digit and contain only lowercase letters, digits, hyphens, and underscores'
+  if (name === '_lib')
+    return '_lib is reserved'
+  return null
+}

package/shared/types/index.ts

@@ -454,6 +454,69 @@ export interface DashboardOverview {
   }
 }
 
+// === Skills ===
+
+export interface SkillMeta {
+  name: string
+  description: string
+  version: string
+  author: string
+  tags: string[]
+  allowedTools: string[]
+  requiresSecrets: string[]
+  repository: string
+  installedFrom: string
+  disableModelInvocation: boolean
+  userInvocable: boolean
+  context: string
+  agent: string
+}
+
+export interface SkillListItem {
+  name: string
+  description: string
+  version: string
+  author: string
+  active: boolean
+  core: boolean
+  allowedTools: string[]
+  requiresSecrets: string[]
+  installedFrom: string
+  fileCount: number
+}
+
+export interface SkillDetail extends SkillListItem {
+  meta: SkillMeta
+  files: SkillFile[]
+}
+
+export interface SkillFile {
+  name: string
+  path: string
+  type: 'file' | 'directory'
+  children?: SkillFile[]
+}
+
+// === Skills Library ===
+
+// First tag must be 'community' or 'official'. Up to 4 additional free-form tags.
+export type SkillSourceTag = 'community' | 'official'
+
+export interface SkillCatalogItem {
+  id: string
+  name: string
+  description: string
+  version: string
+  author: string
+  tags: string[]
+  requiresSecrets: string[]
+  files: string[]
+  updatedAt: string
+  installed?: boolean
+  installedVersion?: string
+  hasUpdate?: boolean
+}
+
 // === Hook Events ===
 
 export type HookEventType