prjct-cli 0.11.5 → 0.12.1

package/core/infrastructure/agents/{claude-agent.js → claude-agent.ts}

@@ -3,9 +3,43 @@
  * Implements prjct commands for Claude Code environment
  */
 
-const fs = require('fs').promises
+import fs from 'fs/promises'
+
+declare const global: typeof globalThis & {
+  mcp?: {
+    filesystem?: {
+      read: (path: string) => Promise<string>
+      write: (path: string, content: string) => Promise<void>
+      list: (path: string) => Promise<string[]>
+    }
+  }
+}
+
+interface RecapData {
+  currentTask?: string | null
+  shippedCount: number
+  queuedCount: number
+  ideasCount: number
+  recentActivity?: string
+}
+
+interface ProgressData {
+  period: string
+  count: number
+  velocity: number
+  previousVelocity: number
+  recentFeatures?: string
+}
+
+interface IntentResult {
+  intent: string
+  command: string | null
+}
 
 class ClaudeAgent {
+  name: string
+  type: string
+
   constructor() {
     this.name = 'Claude Code'
     this.type = 'claude'
@@ -14,8 +48,8 @@ class ClaudeAgent {
   /**
    * Format response - minimal, actionable
    */
-  formatResponse(message, type = 'info') {
-    const emojis = {
+  formatResponse(message: string, type: string = 'info'): string {
+    const emojis: Record<string, string> = {
       success: '✅',
       error: '❌',
       warning: '⚠️',
@@ -34,12 +68,14 @@ class ClaudeAgent {
   /**
    * Read file using MCP if available, fallback to fs
    */
-  async readFile(filePath) {
+  async readFile(filePath: string): Promise<string> {
     try {
       if (global.mcp && global.mcp.filesystem) {
         return await global.mcp.filesystem.read(filePath)
       }
-    } catch (e) {}
+    } catch {
+      // Fall through to fs
+    }
 
     return await fs.readFile(filePath, 'utf8')
   }
@@ -47,12 +83,14 @@ class ClaudeAgent {
   /**
    * Write file using MCP if available, fallback to fs
    */
-  async writeFile(filePath, content) {
+  async writeFile(filePath: string, content: string): Promise<void> {
     try {
       if (global.mcp && global.mcp.filesystem) {
         return await global.mcp.filesystem.write(filePath, content)
       }
-    } catch (e) {}
+    } catch {
+      // Fall through to fs
+    }
 
     await fs.writeFile(filePath, content, 'utf8')
   }
@@ -60,12 +98,14 @@ class ClaudeAgent {
   /**
    * List directory contents
    */
-  async listDirectory(dirPath) {
+  async listDirectory(dirPath: string): Promise<string[]> {
     try {
       if (global.mcp && global.mcp.filesystem) {
         return await global.mcp.filesystem.list(dirPath)
       }
-    } catch (e) {}
+    } catch {
+      // Fall through to fs
+    }
 
     return await fs.readdir(dirPath)
   }
@@ -73,7 +113,7 @@ class ClaudeAgent {
   /**
    * Check if file exists
    */
-  async fileExists(filePath) {
+  async fileExists(filePath: string): Promise<boolean> {
     try {
       await fs.access(filePath)
       return true
@@ -85,21 +125,21 @@ class ClaudeAgent {
   /**
    * Create directory
    */
-  async createDirectory(dirPath) {
+  async createDirectory(dirPath: string): Promise<void> {
     await fs.mkdir(dirPath, { recursive: true })
   }
 
   /**
    * Get current timestamp in ISO format
    */
-  getTimestamp() {
+  getTimestamp(): string {
     return new Date().toISOString()
   }
 
   /**
    * Format task list - data only
    */
-  formatTaskList(tasks) {
+  formatTaskList(tasks: string[] | null): string {
     if (!tasks || tasks.length === 0) {
       return '📋 No tasks queued'
     }
@@ -110,7 +150,7 @@ class ClaudeAgent {
   /**
    * Format recap - metrics only
    */
-  formatRecap(data) {
+  formatRecap(data: RecapData): string {
     return `📊 Recap
 
 🎯 Current: ${data.currentTask || 'None'}
@@ -123,7 +163,7 @@ ${data.recentActivity ? '\n' + data.recentActivity : ''}`
   /**
    * Format progress - data only
    */
-  formatProgress(data) {
+  formatProgress(data: ProgressData): string {
     const trend =
       data.velocity > data.previousVelocity
         ? '📈'
@@ -141,8 +181,8 @@ ${data.recentFeatures || ''}`
   /**
    * Get help - actionable steps only
    */
-  getHelpContent(issue) {
-    const helps = {
+  getHelpContent(issue: string): string {
+    const helps: Record<string, string> = {
       debugging:
         '🔍 1. Isolate code causing error\n2. Add logs at key points\n3. Search exact error message',
       design: '🎨 1. Define problem clearly\n2. Start with simplest solution\n3. Ship MVP, iterate',
@@ -159,8 +199,8 @@ ${data.recentFeatures || ''}`
   /**
    * Suggest next action - conversational prompts
    */
-  suggestNextAction(context) {
-    const suggestions = {
+  suggestNextAction(context: string): string {
+    const suggestions: Record<string, string> = {
       taskCompleted: `What's next?
 • "start [task]" → Begin working
 • "ship feature" → Track & celebrate
@@ -205,7 +245,7 @@ Type /p:help to see all options`
   /**
    * Detect user intent from natural language
    */
-  detectIntent(message) {
+  detectIntent(message: string): IntentResult {
     const msg = message.toLowerCase()
 
     // Start/begin task
@@ -250,4 +290,4 @@ Type /p:help to see all options`
   }
 }
 
-module.exports = ClaudeAgent
+export default ClaudeAgent

package/core/infrastructure/{author-detector.js → author-detector.ts}

@@ -1,7 +1,3 @@
-const { promisify } = require('util')
-const { exec: execCallback } = require('child_process')
-const exec = promisify(execCallback)
-
 /**
  * AuthorDetector - Detects author information from multiple sources
  *
@@ -12,22 +8,43 @@ const exec = promisify(execCallback)
  *
  * @version 0.2.0
  */
+
+import { promisify } from 'util'
+import { exec as execCallback } from 'child_process'
+
+const exec = promisify(execCallback)
+
+interface Author {
+  name: string | null
+  email: string | null
+  github: string | null
+}
+
+interface ExecResult {
+  success: boolean
+  output: string
+}
+
+interface ConfigStatus {
+  hasGitHub: boolean
+  hasGit: boolean
+  author: Author
+  isComplete: boolean
+  recommendations: string[]
+}
+
 class AuthorDetector {
   /**
    * Execute a shell command safely
-   *
-   * @param {string} command - Command to execute
-   * @returns {Promise<{success: boolean, output: string}>}
-   * @private
    */
-  async execCommand(command) {
+  private async execCommand(command: string): Promise<ExecResult> {
     try {
       const { stdout } = await exec(command, { timeout: 5000 })
       return {
         success: true,
         output: stdout.trim(),
       }
-    } catch (error) {
+    } catch {
       return {
         success: false,
         output: '',
@@ -37,10 +54,8 @@ class AuthorDetector {
 
   /**
    * Detect GitHub username using GitHub CLI
-   *
-   * @returns {Promise<string|null>} - GitHub username or null
    */
-  async detectGitHubUsername() {
+  async detectGitHubUsername(): Promise<string | null> {
     let result = await this.execCommand('gh api user --jq .login')
     if (result.success && result.output) {
       return result.output
@@ -56,31 +71,25 @@ class AuthorDetector {
 
   /**
    * Detect git config name
-   *
-   * @returns {Promise<string|null>} - Git name or null
    */
-  async detectGitName() {
+  async detectGitName(): Promise<string | null> {
     const result = await this.execCommand('git config user.name')
     return result.success && result.output ? result.output : null
   }
 
   /**
    * Detect git config email
-   *
-   * @returns {Promise<string|null>} - Git email or null
    */
-  async detectGitEmail() {
+  async detectGitEmail(): Promise<string | null> {
     const result = await this.execCommand('git config user.email')
     return result.success && result.output ? result.output : null
   }
 
   /**
    * Detect author information from all available sources
-   *
-   * @returns {Promise<Object>} - Author information {name, email, github}
    */
-  async detect() {
-    const author = {
+  async detect(): Promise<Author> {
+    const author: Author = {
       name: null,
       email: null,
       github: null,
@@ -105,10 +114,8 @@ class AuthorDetector {
   /**
    * Detect and format author for memory logs
    * Returns just the GitHub username or git name
-   *
-   * @returns {Promise<string>} - Author identifier for logs
    */
-  async detectAuthorForLogs() {
+  async detectAuthorForLogs(): Promise<string> {
     const author = await this.detect()
 
     if (author.github) {
@@ -124,20 +131,16 @@ class AuthorDetector {
 
   /**
    * Check if GitHub CLI is available
-   *
-   * @returns {Promise<boolean>} - True if gh command is available
    */
-  async isGitHubCLIAvailable() {
+  async isGitHubCLIAvailable(): Promise<boolean> {
     const result = await this.execCommand('gh --version')
     return result.success
   }
 
   /**
    * Check if git is configured
-   *
-   * @returns {Promise<boolean>} - True if git name and email are set
    */
-  async isGitConfigured() {
+  async isGitConfigured(): Promise<boolean> {
     const name = await this.detectGitName()
     const email = await this.detectGitEmail()
     return !!(name && email)
@@ -145,10 +148,8 @@ class AuthorDetector {
 
   /**
    * Get configuration status and recommendations
-   *
-   * @returns {Promise<Object>} - Status and recommendations
    */
-  async getConfigStatus() {
+  async getConfigStatus(): Promise<ConfigStatus> {
     const hasGitHub = await this.isGitHubCLIAvailable()
     const hasGit = await this.isGitConfigured()
     const author = await this.detect()
@@ -164,15 +165,9 @@ class AuthorDetector {
 
   /**
    * Generate recommendations based on detected configuration
-   *
-   * @param {boolean} hasGitHub - GitHub CLI available
-   * @param {boolean} hasGit - Git configured
-   * @param {Object} author - Detected author
-   * @returns {string[]} - Array of recommendations
-   * @private
    */
-  _getRecommendations(hasGitHub, hasGit, author) {
-    const recommendations = []
+  private _getRecommendations(hasGitHub: boolean, hasGit: boolean, author: Author): string[] {
+    const recommendations: string[] = []
 
     if (!hasGitHub && !author.github) {
       recommendations.push(
@@ -194,12 +189,9 @@ class AuthorDetector {
 
   /**
    * Format author information for display
-   *
-   * @param {Object} author - Author object
-   * @returns {string} - Formatted author string
    */
-  formatAuthor(author) {
-    const parts = []
+  formatAuthor(author: Author): string {
+    const parts: string[] = []
 
     if (author.name && author.name !== 'Unknown') {
       parts.push(author.name)
@@ -217,4 +209,5 @@ class AuthorDetector {
   }
 }
 
-module.exports = new AuthorDetector()
+const authorDetector = new AuthorDetector()
+export default authorDetector

package/core/infrastructure/{capability-installer.js → capability-installer.ts}

@@ -3,15 +3,48 @@
  * Handles installation of missing tools and tracks them as workflow tasks
  */
 
-const { exec } = require('child_process')
-const { promisify } = require('util')
+import { exec } from 'child_process'
+import { promisify } from 'util'
+import fs from 'fs/promises'
+import path from 'path'
+import projectCapabilities from '../utils/project-capabilities'
+
 const execAsync = promisify(exec)
 
+interface Recommendation {
+  install: string
+}
+
+interface InstallResult {
+  success: boolean
+  capability: string
+  command: string
+  duration?: number
+  output?: string
+  errors?: string | null
+  error?: string
+}
+
+interface ConfigureResult {
+  configured: boolean
+  framework?: string
+  tool?: string
+}
+
+interface PackageJson {
+  devDependencies?: Record<string, string>
+  scripts?: Record<string, string>
+}
+
 class CapabilityInstaller {
   /**
    * Install capability and create tracking task
    */
-  async install(capability, recommendation, _dataPath) {
+  async install(
+    capability: string,
+    recommendation: Recommendation,
+    _dataPath: string
+  ): Promise<InstallResult> {
     const command = recommendation.install
     const startTime = Date.now()
 
@@ -35,7 +68,7 @@ class CapabilityInstaller {
         success: false,
         capability,
         command,
-        error: error.message,
+        error: (error as Error).message,
       }
     }
   }
@@ -43,8 +76,8 @@ class CapabilityInstaller {
   /**
    * Create configuration for installed tool
    */
-  async configure(capability, projectPath) {
-    const configs = {
+  async configure(capability: string, projectPath: string): Promise<ConfigureResult> {
+    const configs: Record<string, () => Promise<ConfigureResult>> = {
       test: () => this.configureTest(projectPath),
       design: () => this.configureDesign(projectPath),
       docs: () => this.configureDocs(projectPath),
@@ -60,13 +93,10 @@ class CapabilityInstaller {
   /**
    * Configure test framework
    */
-  async configureTest(projectPath) {
-    const fs = require('fs').promises
-    const path = require('path')
-
+  async configureTest(projectPath: string): Promise<ConfigureResult> {
     // Check if package.json exists
     const pkgPath = path.join(projectPath, 'package.json')
-    const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'))
+    const pkg: PackageJson = JSON.parse(await fs.readFile(pkgPath, 'utf8'))
 
     const hasVitest = pkg.devDependencies?.vitest
     const hasJest = pkg.devDependencies?.jest
@@ -121,12 +151,9 @@ export default defineConfig({
   /**
    * Configure design system
    */
-  async configureDesign(projectPath) {
-    const fs = require('fs').promises
-    const path = require('path')
-
+  async configureDesign(projectPath: string): Promise<ConfigureResult> {
     const pkgPath = path.join(projectPath, 'package.json')
-    const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'))
+    const pkg: PackageJson = JSON.parse(await fs.readFile(pkgPath, 'utf8'))
 
     if (pkg.devDependencies?.storybook) {
       // Storybook auto-configures itself during init
@@ -139,19 +166,16 @@ export default defineConfig({
   /**
    * Configure documentation
    */
-  async configureDocs(projectPath) {
-    const fs = require('fs').promises
-    const path = require('path')
-
+  async configureDocs(projectPath: string): Promise<ConfigureResult> {
     const pkgPath = path.join(projectPath, 'package.json')
-    const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'))
+    const pkg: PackageJson = JSON.parse(await fs.readFile(pkgPath, 'utf8'))
 
     if (pkg.devDependencies?.jsdoc) {
       // Create jsdoc.json
       const config = {
         source: {
           include: ['src'],
-          includePattern: '.+\\\\.js(doc|x)?$',
+          includePattern: '.+\\.js(doc|x)?$',
           excludePattern: '(node_modules|docs)',
         },
         opts: {
@@ -176,12 +200,12 @@ export default defineConfig({
   /**
    * Verify installation succeeded
    */
-  async verify(capability, projectPath) {
-    const caps = require('../utils/project-capabilities')
-    const detected = await caps.detect(projectPath)
+  async verify(capability: string, projectPath: string): Promise<boolean> {
+    const detected = await projectCapabilities.detect(projectPath)
 
-    return detected[capability] === true
+    return detected[capability as keyof typeof detected] === true
   }
 }
 
-module.exports = new CapabilityInstaller()
+const capabilityInstaller = new CapabilityInstaller()
+export default capabilityInstaller