prjct-cli 0.20.0 → 0.21.0

package/core/agentic/skill-loader.ts

@@ -0,0 +1,112 @@
+/**
+ * Skill Loader for Agentic System
+ *
+ * Integrates skills into the prompt builder and context system.
+ * Formats skills for Claude consumption.
+ *
+ * @version 1.0.0
+ */
+
+import skillService from '../services/skill-service'
+import type { Skill, FormattedSkill, SkillContext } from '../types'
+
+/**
+ * Format a skill for inclusion in prompts
+ */
+function formatSkillForPrompt(skill: Skill): FormattedSkill {
+  return {
+    id: skill.id,
+    name: skill.name,
+    description: skill.description,
+    prompt: skill.content,
+  }
+}
+
+/**
+ * Generate markdown listing of available skills
+ */
+function generateSkillsMarkdown(skills: Skill[]): string {
+  if (skills.length === 0) {
+    return ''
+  }
+
+  const lines: string[] = [
+    '## Available Skills',
+    '',
+    'The following skills can be invoked:',
+    '',
+  ]
+
+  for (const skill of skills) {
+    lines.push(`- **${skill.name}** (\`${skill.id}\`): ${skill.description || 'No description'}`)
+    if (skill.metadata.agent) {
+      lines.push(`  - Agent: ${skill.metadata.agent}`)
+    }
+    if (skill.metadata.tags?.length) {
+      lines.push(`  - Tags: ${skill.metadata.tags.join(', ')}`)
+    }
+  }
+
+  return lines.join('\n')
+}
+
+/**
+ * Load skills and prepare context for prompts
+ */
+export async function loadSkillContext(projectPath?: string): Promise<SkillContext> {
+  const skills = await skillService.getAll(projectPath)
+
+  return {
+    availableSkills: skills.map(formatSkillForPrompt),
+    skillsMarkdown: generateSkillsMarkdown(skills),
+  }
+}
+
+/**
+ * Get a specific skill's prompt content
+ */
+export async function getSkillPrompt(skillId: string, projectPath?: string): Promise<string | null> {
+  const skill = await skillService.get(skillId, projectPath)
+  return skill?.content || null
+}
+
+/**
+ * Find best matching skill for a query
+ */
+export async function findBestSkill(query: string, projectPath?: string): Promise<Skill | null> {
+  const results = await skillService.search(query, projectPath)
+  return results[0]?.skill || null
+}
+
+/**
+ * Format skill invocation result
+ */
+export function formatSkillResult(skill: Skill, result: string): string {
+  return [
+    `## Skill Executed: ${skill.name}`,
+    '',
+    result,
+    '',
+    `---`,
+    `*Skill: ${skill.id} | Source: ${skill.source}*`,
+  ].join('\n')
+}
+
+/**
+ * Build skill section for system prompt
+ */
+export async function buildSkillSystemPrompt(projectPath?: string): Promise<string> {
+  const { availableSkills, skillsMarkdown } = await loadSkillContext(projectPath)
+
+  if (availableSkills.length === 0) {
+    return ''
+  }
+
+  return [
+    '<skills>',
+    skillsMarkdown,
+    '',
+    'To invoke a skill, use the skill ID.',
+    '</skills>',
+  ].join('\n')
+}

package/core/agentic/smart-context.ts

@@ -10,127 +10,30 @@
 
 import { agentPerformanceTracker } from '../agents'
 import { outcomeAnalyzer } from '../outcomes'
-import type { TaskType } from '../agents/types'
-
-// Local interface for context state
-interface ProjectState {
-  projectId: string
-  currentTask: { description: string; startedAt: string } | null
-  queue: { description: string; priority: string }[]
-}
-
-/**
- * Context domain for filtering.
- */
-export type ContextDomain = 'frontend' | 'backend' | 'devops' | 'docs' | 'testing' | 'general'
-
-/**
- * Full context available before filtering.
- */
-export interface FullContext {
-  /** Project state */
-  state: ProjectState | null
-
-  /** Available agents */
-  agents: AgentInfo[]
-
-  /** Roadmap features */
-  roadmap: FeatureInfo[]
-
-  /** Detected patterns */
-  patterns: PatternInfo[]
-
-  /** Tech stack info */
-  stack: StackInfo
-
-  /** File list */
-  files: string[]
-
-  /** Project path */
-  projectPath: string
-}
-
-/**
- * Filtered context optimized for a task domain.
- */
-export interface FilteredContext {
-  /** Filtered agents (domain-relevant only) */
-  agents: AgentInfo[]
-
-  /** Filtered roadmap (related features only) */
-  roadmap: FeatureInfo[]
-
-  /** Filtered patterns (domain-relevant only) */
-  patterns: PatternInfo[]
-
-  /** Filtered stack info */
-  stack: Partial<StackInfo>
-
-  /** Filtered files */
-  files: string[]
-
-  /** Filtering metrics */
-  metrics: FilterMetrics
-}
-
-/**
- * Agent info for context.
- */
-export interface AgentInfo {
-  name: string
-  domain: ContextDomain
-  skills: string[]
-  successRate?: number
-}
-
-/**
- * Feature info for context.
- */
-export interface FeatureInfo {
-  id: string
-  name: string
-  relatedTo: ContextDomain[]
-  status: string
-}
-
-/**
- * Pattern info for context.
- */
-export interface PatternInfo {
-  description: string
-  domain: ContextDomain
-  confidence: number
-}
-
-/**
- * Stack info for context.
- */
-export interface StackInfo {
-  frontend: string[]
-  backend: string[]
-  devops: string[]
-  database: string[]
-  testing: string[]
-}
-
-/**
- * Filtering metrics.
- */
-export interface FilterMetrics {
-  originalSize: number
-  filteredSize: number
-  reductionPercent: number
-  domain: ContextDomain
-}
-
-/**
- * Domain detection result.
- */
-interface DomainAnalysis {
-  primary: ContextDomain
-  secondary: ContextDomain[]
-  confidence: number
-}
+import type { TaskType } from '../types'
+import type {
+  ContextDomain,
+  SmartContextProjectState,
+  FullContext,
+  FilteredContext,
+  StackInfo,
+  DomainAnalysis,
+} from '../types'
+
+// Re-export types for convenience
+export type {
+  ContextDomain,
+  FullContext,
+  FilteredContext,
+  AgentInfo,
+  FeatureInfo,
+  PatternInfo,
+  StackInfo,
+  FilterMetrics,
+} from '../types'
+
+// Local type alias for backward compatibility
+type ProjectState = SmartContextProjectState
 
 /**
  * SmartContext - Intelligent context filtering.
@@ -171,7 +74,19 @@ class SmartContext {
 
     // Testing indicators
     const testingKeywords = [
-      'test', 'spec', 'jest', 'vitest', 'mocha', 'cypress', 'playwright',
+      'test', 'spec',
+      // JS/TS
+      'bun', 'bun test', 'jest', 'mocha', 'cypress', 'playwright',
+      // Python
+      'pytest', 'unittest',
+      // Go
+      'go test',
+      // Rust
+      'cargo test',
+      // .NET
+      'dotnet test',
+      // Java
+      'mvn test', 'gradle test', 'gradlew test',
       'e2e', 'unit', 'integration', 'coverage', 'mock', 'fixture'
     ]
 

package/core/agentic/template-loader.ts

@@ -3,153 +3,110 @@
  * Loads and parses command templates with frontmatter.
  *
  * @module agentic/template-loader
- * @version 1.0.0
  */
 
 import fs from 'fs/promises'
 import path from 'path'
 import { TemplateError } from '../errors'
+import type { Frontmatter, ParsedTemplate } from '../types'
 
-interface Frontmatter {
-  name?: string
-  description?: string
-  'allowed-tools'?: string[]
-  [key: string]: string | string[] | undefined
-}
+// ============ Module State (LRU Cache) ============
+
+const TEMPLATES_DIR = path.join(__dirname, '..', '..', 'templates', 'commands')
+const MAX_CACHE_SIZE = 50
+
+const cache = new Map<string, ParsedTemplate>()
+const cacheOrder: string[] = []
+
+// ============ Cache Helpers ============
 
-interface ParsedTemplate {
-  frontmatter: Frontmatter
-  content: string
+function updateLruOrder(key: string): void {
+  const index = cacheOrder.indexOf(key)
+  if (index > -1) cacheOrder.splice(index, 1)
+  cacheOrder.push(key)
 }
 
-/**
- * Loads command templates from templates/commands/ with caching.
- * Parses YAML-like frontmatter for metadata extraction.
- * Uses LRU cache with size limit to prevent memory leaks.
- */
-class TemplateLoader {
-  templatesDir: string
-  cache: Map<string, ParsedTemplate>
-  cacheOrder: string[] // Track access order for LRU eviction
-  maxCacheSize: number
-
-  constructor() {
-    this.templatesDir = path.join(__dirname, '..', '..', 'templates', 'commands')
-    this.cache = new Map()
-    this.cacheOrder = []
-    this.maxCacheSize = 50 // More than enough for all commands
+function evictLru(): void {
+  while (cache.size >= MAX_CACHE_SIZE && cacheOrder.length > 0) {
+    const oldest = cacheOrder.shift()
+    if (oldest) cache.delete(oldest)
   }
+}
 
-  /**
-   * Update LRU order - move key to end (most recently used)
-   */
-  private updateLruOrder(key: string): void {
-    const index = this.cacheOrder.indexOf(key)
-    if (index > -1) {
-      this.cacheOrder.splice(index, 1)
-    }
-    this.cacheOrder.push(key)
-  }
+// ============ Parsing Functions ============
 
-  /**
-   * Evict least recently used entry if cache exceeds max size
-   */
-  private evictLru(): void {
-    while (this.cache.size >= this.maxCacheSize && this.cacheOrder.length > 0) {
-      const oldest = this.cacheOrder.shift()
-      if (oldest) {
-        this.cache.delete(oldest)
-      }
-    }
+export function parseFrontmatter(content: string): ParsedTemplate {
+  const frontmatterRegex = /^---\n([\s\S]+?)\n---\n([\s\S]*)$/
+  const match = content.match(frontmatterRegex)
+
+  if (!match) {
+    return { frontmatter: {}, content: content.trim() }
   }
 
-  /**
-   * Load template with frontmatter
-   */
-  async load(commandName: string): Promise<ParsedTemplate> {
-    // Check cache first
-    if (this.cache.has(commandName)) {
-      this.updateLruOrder(commandName)
-      return this.cache.get(commandName)!
-    }
+  const [, frontmatterText, mainContent] = match
+  const frontmatter: Frontmatter = {}
 
-    const templatePath = path.join(this.templatesDir, `${commandName}.md`)
+  frontmatterText.split('\n').forEach((line) => {
+    const [key, ...valueParts] = line.split(':')
+    if (key && valueParts.length > 0) {
+      const value = valueParts.join(':').trim()
 
-    try {
-      const rawContent = await fs.readFile(templatePath, 'utf-8')
-      const parsed = this.parseFrontmatter(rawContent)
+      // Parse arrays
+      if (value.startsWith('[') && value.endsWith(']')) {
+        frontmatter[key.trim()] = value.slice(1, -1).split(',').map((v) => v.trim())
+      } else {
+        // Remove quotes if present
+        frontmatter[key.trim()] = value.replace(/^["']|["']$/g, '')
+      }
+    }
+  })
 
-      // Evict LRU if needed before adding
-      this.evictLru()
+  return { frontmatter, content: mainContent.trim() }
+}
 
-      // Cache result
-      this.cache.set(commandName, parsed)
-      this.cacheOrder.push(commandName)
+// ============ Main Functions ============
 
-      return parsed
-    } catch {
-      throw TemplateError.notFound(commandName)
-    }
+export async function load(commandName: string): Promise<ParsedTemplate> {
+  // Check cache first
+  if (cache.has(commandName)) {
+    updateLruOrder(commandName)
+    return cache.get(commandName)!
   }
 
-  /**
-   * Parse frontmatter from markdown
-   */
-  parseFrontmatter(content: string): ParsedTemplate {
-    const frontmatterRegex = /^---\n([\s\S]+?)\n---\n([\s\S]*)$/
-    const match = content.match(frontmatterRegex)
-
-    if (!match) {
-      return {
-        frontmatter: {},
-        content: content.trim(),
-      }
-    }
+  const templatePath = path.join(TEMPLATES_DIR, `${commandName}.md`)
 
-    const [, frontmatterText, mainContent] = match
-    const frontmatter: Frontmatter = {}
-
-    // Parse frontmatter lines
-    frontmatterText.split('\n').forEach((line) => {
-      const [key, ...valueParts] = line.split(':')
-      if (key && valueParts.length > 0) {
-        const value = valueParts.join(':').trim()
-
-        // Parse arrays
-        if (value.startsWith('[') && value.endsWith(']')) {
-          frontmatter[key.trim()] = value
-            .slice(1, -1)
-            .split(',')
-            .map((v) => v.trim())
-        } else {
-          // Remove quotes if present
-          frontmatter[key.trim()] = value.replace(/^["']|["']$/g, '')
-        }
-      }
-    })
+  try {
+    const rawContent = await fs.readFile(templatePath, 'utf-8')
+    const parsed = parseFrontmatter(rawContent)
 
-    return {
-      frontmatter,
-      content: mainContent.trim(),
-    }
-  }
+    // Evict LRU if needed before adding
+    evictLru()
 
-  /**
-   * Get allowed tools for a command
-   */
-  async getAllowedTools(commandName: string): Promise<string[]> {
-    const template = await this.load(commandName)
-    return template.frontmatter['allowed-tools'] || []
-  }
+    // Cache result
+    cache.set(commandName, parsed)
+    cacheOrder.push(commandName)
 
-  /**
-   * Clear cache (useful for testing)
-   */
-  clearCache(): void {
-    this.cache.clear()
+    return parsed
+  } catch {
+    throw TemplateError.notFound(commandName)
   }
 }
 
-const templateLoader = new TemplateLoader()
-export default templateLoader
-export { TemplateLoader }
+export async function getAllowedTools(commandName: string): Promise<string[]> {
+  const template = await load(commandName)
+  return template.frontmatter['allowed-tools'] || []
+}
+
+export function clearCache(): void {
+  cache.clear()
+  cacheOrder.length = 0
+}
+
+// ============ Default Export (backwards compat) ============
+
+export default {
+  load,
+  parseFrontmatter,
+  getAllowedTools,
+  clearCache
+}

package/core/agentic/tool-registry.ts

@@ -9,20 +9,14 @@
 import fs from 'fs/promises'
 import { exec } from 'child_process'
 import { promisify } from 'util'
+import type { ToolFunction, ToolRegistryInterface } from '../types'
 
-const execAsync = promisify(exec)
-
-type ToolFunction = (...args: unknown[]) => Promise<unknown>
+// Re-export types for convenience
+export type { ToolFunction, ToolRegistryInterface } from '../types'
 
-interface ToolRegistry {
-  tools: Map<string, ToolFunction>
-  register(name: string, fn: ToolFunction): void
-  get(name: string): ToolFunction | undefined
-  isAllowed(name: string, allowedTools: string[]): boolean
-  list(): string[]
-}
+const execAsync = promisify(exec)
 
-const toolRegistry: ToolRegistry = {
+const toolRegistry: ToolRegistryInterface = {
   tools: new Map(),
 
   /**

package/core/agents/index.ts

@@ -25,4 +25,4 @@
  */
 
 export { AgentPerformanceTracker, default as agentPerformanceTracker } from './performance'
-export * from './types'
+export * from '../types'

package/core/agents/performance.ts

@@ -14,7 +14,7 @@ import type {
   AgentSuggestion,
   AgentPerformanceSummary,
   TaskType,
-} from './types'
+} from '../types'
 
 const PERFORMANCE_DIR = 'analysis'
 const PERFORMANCE_FILE = 'agent-performance.json'
@@ -98,7 +98,7 @@ export class AgentPerformanceTracker {
       perfPath,
       { agents: [] }
     )
-    return data.agents
+    return data?.agents ?? []
   }
 
   /**
@@ -127,6 +127,8 @@ export class AgentPerformanceTracker {
       { agents: [] }
     )
 
+    if (!data) return
+
     // Find or create agent performance
     let agentPerf = data.agents.find((a) => a.agentName === record.agentName)