prjct-cli 0.45.0 → 0.45.3

package/core/commands/planning.ts

@@ -3,25 +3,25 @@
  * Write-Through Architecture: JSON → MD → Event
  */
 
-import path from 'path'
-
-import type { CommandResult, ProjectContext } from '../types'
+import path from 'node:path'
+import authorDetector from '../infrastructure/author-detector'
+import commandInstaller from '../infrastructure/command-installer'
 import { generateUUID } from '../schemas'
-import type { Priority, TaskType, TaskSection } from '../schemas/state'
+import type { Priority, TaskSection, TaskType } from '../schemas/state'
+import { ideasStorage, queueStorage } from '../storage'
+import type { CommandResult, ProjectContext } from '../types'
+import { showNextSteps } from '../utils/next-steps'
+import { OnboardingWizard } from '../wizard'
 import {
-  PrjctCommandsBase,
-  contextBuilder,
-  toolRegistry,
-  pathManager,
   configManager,
-  fileHelper,
+  contextBuilder,
   dateHelper,
-  out
+  fileHelper,
+  out,
+  PrjctCommandsBase,
+  pathManager,
+  toolRegistry,
 } from './base'
-import { queueStorage, ideasStorage } from '../storage'
-import authorDetector from '../infrastructure/author-detector'
-import commandInstaller from '../infrastructure/command-installer'
-import { showNextSteps } from '../utils/next-steps'
 
 // Lazy-loaded to avoid circular dependencies
 let _analysisCommands: import('./analysis').AnalysisCommands | null = null
@@ -33,12 +33,32 @@ async function getAnalysisCommands(): Promise<import('./analysis').AnalysisComma
   return _analysisCommands
 }
 
+export interface InitOptions {
+  yes?: boolean // Skip interactive wizard, use defaults
+  idea?: string | null // Initial idea for architect mode
+}
+
 export class PlanningCommands extends PrjctCommandsBase {
   /**
-   * /p:init - Initialize prjct project
+   * /p:init - Initialize prjct project with interactive wizard
+   *
+   * @param options.yes - Skip wizard, use auto-detected values (for CI)
+   * @param options.idea - Initial idea for architect mode
+   * @param projectPath - Project directory path
    */
-  async init(idea: string | null = null, projectPath: string = process.cwd()): Promise<CommandResult> {
+  async init(
+    options: InitOptions | string | null = {},
+    projectPath: string = process.cwd()
+  ): Promise<CommandResult> {
     try {
+      // Handle legacy signature: init(idea, projectPath)
+      let opts: InitOptions = {}
+      if (typeof options === 'string' || options === null) {
+        opts = { idea: options }
+      } else {
+        opts = options
+      }
+
       await this.initializeAgent()
 
       const isConfigured = await configManager.isConfigured(projectPath)
@@ -48,6 +68,25 @@ export class PlanningCommands extends PrjctCommandsBase {
         return { success: false, message: 'Already initialized' }
       }
 
+      // Determine if we should run interactive wizard
+      const isTTY = process.stdout.isTTY && process.stdin.isTTY
+      const skipWizard = opts.yes || !isTTY || process.env.CI === 'true'
+
+      // Run wizard if interactive
+      let wizardResult = null
+      if (!skipWizard) {
+        const wizard = new OnboardingWizard(projectPath)
+        wizardResult = await wizard.run()
+
+        if (wizardResult.skipped) {
+          return { success: false, message: 'Setup cancelled' }
+        }
+      } else if (isTTY && opts.yes) {
+        // Non-interactive but show progress
+        const wizard = new OnboardingWizard(projectPath)
+        wizardResult = await wizard.runNonInteractive()
+      }
+
       out.step(1, 4, 'Detecting author...')
 
       const detectedAuthor = await authorDetector.detect()
@@ -55,7 +94,7 @@ export class PlanningCommands extends PrjctCommandsBase {
       const author = {
         name: detectedAuthor.name || undefined,
         email: detectedAuthor.email || undefined,
-        github: detectedAuthor.github || undefined
+        github: detectedAuthor.github || undefined,
       }
       const config = await configManager.createConfig(projectPath, author)
       const projectId = config.projectId
@@ -75,13 +114,32 @@ export class PlanningCommands extends PrjctCommandsBase {
         'planning/roadmap.md': '# ROADMAP\n\n',
         'planning/specs/.gitkeep': '# Specs directory - created by /p:spec\n',
         'memory/context.jsonl': '',
-        'memory/patterns.json': JSON.stringify({
-          version: 1,
-          decisions: {},
-          preferences: {},
-          workflows: {},
-          counters: {}
-        }, null, 2),
+        'memory/patterns.json': JSON.stringify(
+          {
+            version: 1,
+            decisions: {},
+            preferences: {},
+            workflows: {},
+            counters: {},
+          },
+          null,
+          2
+        ),
+      }
+
+      // Save wizard preferences if available
+      if (wizardResult) {
+        baseFiles['config/wizard.json'] = JSON.stringify(
+          {
+            projectType: wizardResult.projectType,
+            agents: wizardResult.agents,
+            stack: wizardResult.stack,
+            preferences: wizardResult.preferences,
+            createdAt: new Date().toISOString(),
+          },
+          null,
+          2
+        )
       }
 
       for (const [filePath, content] of Object.entries(baseFiles)) {
@@ -98,16 +156,25 @@ export class PlanningCommands extends PrjctCommandsBase {
 
         if (analysisResult.success) {
           out.step(4, 4, 'Generating agents...')
-          await analysis.sync(projectPath)
+
+          // Pass wizard agent selection to sync if available
+          if (wizardResult?.agents) {
+            await analysis.sync(projectPath, { aiTools: wizardResult.agents })
+          } else {
+            await analysis.sync(projectPath)
+          }
+
           out.done('initialized')
-          return { success: true, mode: 'existing', projectId }
+          this._printNextSteps(wizardResult)
+          return { success: true, mode: 'existing', projectId, wizard: wizardResult }
         }
       }
 
+      const idea = opts.idea
       if (isEmpty && !hasCode) {
         if (!idea) {
           out.done('blank project - provide idea for architect mode')
-          return { success: true, mode: 'blank_no_idea', projectId }
+          return { success: true, mode: 'blank_no_idea', projectId, wizard: wizardResult }
         }
 
         out.spin('architect mode...')
@@ -118,20 +185,60 @@ export class PlanningCommands extends PrjctCommandsBase {
         await commandInstaller.installGlobalConfig()
 
         out.done('architect mode ready')
-        return { success: true, mode: 'architect', projectId, idea }
+        return { success: true, mode: 'architect', projectId, idea, wizard: wizardResult }
       }
 
       await commandInstaller.installGlobalConfig()
 
       out.done('initialized')
-      showNextSteps('init')
-      return { success: true, projectId }
+      this._printNextSteps(wizardResult)
+      return { success: true, projectId, wizard: wizardResult }
     } catch (error) {
       out.fail((error as Error).message)
       return { success: false, error: (error as Error).message }
     }
   }
 
+  /**
+   * Print next steps after initialization
+   */
+  private _printNextSteps(wizardResult: import('../wizard').WizardResult | null): void {
+    console.log('')
+    console.log('  Quick start:')
+    console.log('    prjct sync     Update context after changes')
+    console.log('    prjct task     Start working on a task')
+    console.log('')
+
+    if (wizardResult) {
+      const agentFiles = wizardResult.agents
+        .map((a) => {
+          switch (a) {
+            case 'claude':
+              return 'CLAUDE.md'
+            case 'cursor':
+              return '.cursorrules'
+            case 'windsurf':
+              return '.windsurfrules'
+            case 'copilot':
+              return '.github/copilot-instructions.md'
+            case 'gemini':
+              return 'GEMINI.md'
+            default:
+              return null
+          }
+        })
+        .filter(Boolean)
+
+      if (agentFiles.length > 0) {
+        console.log(`  Generated: ${agentFiles.join(', ')}`)
+        console.log('')
+      }
+    }
+
+    console.log('  Docs: https://prjct.app/docs')
+    console.log('')
+  }
+
   /**
    * /p:feature - Add feature with value analysis, roadmap, and task breakdown
    */
@@ -153,7 +260,7 @@ export class PlanningCommands extends PrjctCommandsBase {
 
       out.spin(`planning ${description}...`)
 
-      const context = await contextBuilder.build(projectPath, { description }) as ProjectContext
+      const context = (await contextBuilder.build(projectPath, { description })) as ProjectContext
       const tasks = this._breakdownFeatureTasks(description)
       const featureId = generateUUID()
 
@@ -165,21 +272,24 @@ export class PlanningCommands extends PrjctCommandsBase {
       }
 
       // Write-through: Add tasks (JSON → MD → Event)
-      await queueStorage.addTasks(projectId, tasksWithAgents.map(t => ({
-        description: t.task,
-        priority: 'medium' as Priority,
-        type: 'feature' as TaskType,
-        section: 'active' as TaskSection,
-        featureId,
-        originFeature: description,
-        agent: t.agent
-      })))
+      await queueStorage.addTasks(
+        projectId,
+        tasksWithAgents.map((t) => ({
+          description: t.task,
+          priority: 'medium' as Priority,
+          type: 'feature' as TaskType,
+          section: 'active' as TaskSection,
+          featureId,
+          originFeature: description,
+          agent: t.agent,
+        }))
+      )
 
       await this.logToMemory(projectPath, 'feature_planned', {
         feature: description,
         featureId,
         tasks: tasksWithAgents.length,
-        assignments: tasksWithAgents.map(t => ({ task: t.task, agent: t.agent })),
+        assignments: tasksWithAgents.map((t) => ({ task: t.task, agent: t.agent })),
         timestamp: dateHelper.getTimestamp(),
       })
 
@@ -187,7 +297,9 @@ export class PlanningCommands extends PrjctCommandsBase {
         acc[t.agent] = (acc[t.agent] || 0) + 1
         return acc
       }, {})
-      const agentSummary = Object.entries(agentCounts).map(([a, c]) => `${a}:${c}`).join(' ')
+      const agentSummary = Object.entries(agentCounts)
+        .map(([a, c]) => `${a}:${c}`)
+        .join(' ')
 
       out.done(`${tasks.length} tasks [${agentSummary}]`)
 
@@ -219,18 +331,22 @@ export class PlanningCommands extends PrjctCommandsBase {
 
       out.spin('tracking bug...')
 
-      const context = await contextBuilder.build(projectPath, { description }) as ProjectContext
+      const context = (await contextBuilder.build(projectPath, { description })) as ProjectContext
       const severity = this._detectBugSeverity(description)
 
-      const agentResult = await this._assignAgentForTask(`fix bug: ${description}`, projectPath, context)
+      const agentResult = await this._assignAgentForTask(
+        `fix bug: ${description}`,
+        projectPath,
+        context
+      )
       const agent = agentResult.agent?.name || 'generalist'
 
       // Map severity to Priority type
       const priorityMap: Record<string, Priority> = {
-        'critical': 'critical',
-        'high': 'high',
-        'medium': 'medium',
-        'low': 'low'
+        critical: 'critical',
+        high: 'high',
+        medium: 'medium',
+        low: 'low',
       }
       const priority = priorityMap[severity] || 'medium'
 
@@ -240,7 +356,7 @@ export class PlanningCommands extends PrjctCommandsBase {
         priority,
         type: 'bug' as TaskType,
         section: 'active' as TaskSection,
-        agent
+        agent,
       })
 
       await this.logToMemory(projectPath, 'bug_reported', {
@@ -264,7 +380,10 @@ export class PlanningCommands extends PrjctCommandsBase {
   /**
    * /p:architect - Execute architect plan and generate code
    */
-  async architect(action: string = 'execute', projectPath: string = process.cwd()): Promise<CommandResult> {
+  async architect(
+    action: string = 'execute',
+    projectPath: string = process.cwd()
+  ): Promise<CommandResult> {
     if (action !== 'execute') {
       return {
         success: false,
@@ -319,7 +438,7 @@ export class PlanningCommands extends PrjctCommandsBase {
       console.log(`\n🔧 Stack:\n${stack}`)
       console.log(`\n📋 Implementation Steps:\n${steps}`)
 
-      console.log('\n' + '='.repeat(60))
+      console.log(`\n${'='.repeat(60)}`)
       console.log('🤖 READY TO GENERATE CODE')
       console.log('='.repeat(60))
 
@@ -372,7 +491,8 @@ export class PlanningCommands extends PrjctCommandsBase {
 
       // Determine if simple or complex idea
       const wordCount = description.split(/\s+/).length
-      const isComplex = wordCount > 20 || description.includes('with') || description.includes('that')
+      const isComplex =
+        wordCount > 20 || description.includes('with') || description.includes('that')
 
       if (isComplex) {
         // Complex idea → Create architecture session
@@ -432,7 +552,10 @@ Generated: ${new Date().toLocaleString()}
   /**
    * /p:spec - Create detailed specifications for complex features
    */
-  async spec(featureName: string | null = null, projectPath: string = process.cwd()): Promise<CommandResult> {
+  async spec(
+    featureName: string | null = null,
+    projectPath: string = process.cwd()
+  ): Promise<CommandResult> {
     try {
       const initResult = await this.ensureProjectInit(projectPath)
       if (!initResult.success) return initResult
@@ -451,9 +574,9 @@ Generated: ${new Date().toLocaleString()}
         const specsPath = path.join(globalPath, 'planning', 'specs')
 
         try {
-          const fs = await import('fs/promises')
+          const fs = await import('node:fs/promises')
           const files = await fs.readdir(specsPath)
-          const specs = files.filter(f => f.endsWith('.md') && f !== '.gitkeep')
+          const specs = files.filter((f) => f.endsWith('.md') && f !== '.gitkeep')
 
           if (specs.length === 0) {
             out.warn('no specs yet')
@@ -467,7 +590,7 @@ Generated: ${new Date().toLocaleString()}
             const name = s.replace('.md', '').replace(/-/g, ' ')
             console.log(`  ${i + 1}. ${name}`)
           })
-          console.log('═'.repeat(50) + '\n')
+          console.log(`${'═'.repeat(50)}\n`)
 
           return { success: true, specs }
         } catch (_error) {

package/core/commands/register.ts

@@ -8,16 +8,17 @@
  * - Future migration to pure handler pattern
  */
 
-import { commandRegistry } from './registry'
-import { COMMANDS, CATEGORIES } from './command-data'
-import { WorkflowCommands } from './workflow'
-import { PlanningCommands } from './planning'
-import { ShippingCommands } from './shipping'
+import { AnalysisCommands } from './analysis'
 import { AnalyticsCommands } from './analytics'
+import { CATEGORIES, COMMANDS } from './command-data'
+import { ContextCommands } from './context'
 import { MaintenanceCommands } from './maintenance'
-import { AnalysisCommands } from './analysis'
+import { PlanningCommands } from './planning'
+import { commandRegistry } from './registry'
 import { SetupCommands } from './setup'
-import { ContextCommands } from './context'
+import { ShippingCommands } from './shipping'
+import { UninstallCommands } from './uninstall'
+import { WorkflowCommands } from './workflow'
 
 // Singleton instances of command groups
 const workflow = new WorkflowCommands()
@@ -28,6 +29,7 @@ const maintenance = new MaintenanceCommands()
 const analysis = new AnalysisCommands()
 const setup = new SetupCommands()
 const context = new ContextCommands()
+const uninstallCmd = new UninstallCommands()
 
 /**
  * Register categories
@@ -49,7 +51,7 @@ export function registerAllCommands(): void {
   registerCategories()
 
   // Helper to get metadata from COMMANDS
-  const getMeta = (name: string) => COMMANDS.find(c => c.name === name)
+  const getMeta = (name: string) => COMMANDS.find((c) => c.name === name)
 
   // Workflow commands
   commandRegistry.registerMethod('done', workflow, 'done', getMeta('done'))
@@ -86,6 +88,7 @@ export function registerAllCommands(): void {
   // Setup commands
   commandRegistry.registerMethod('start', setup, 'start', getMeta('start'))
   commandRegistry.registerMethod('setup', setup, 'setup', getMeta('setup'))
+  commandRegistry.registerMethod('uninstall', uninstallCmd, 'uninstall', getMeta('uninstall'))
 
   // Context command (for Claude templates)
   commandRegistry.registerMethod('context', context, 'context', getMeta('context'))
@@ -103,5 +106,6 @@ export {
   maintenance,
   analysis,
   setup,
-  context
+  context,
+  uninstallCmd,
 }

package/core/commands/registry.ts

@@ -5,30 +5,30 @@
  * Each command is registered as a handler that receives context and returns a result.
  */
 
-import type { CommandResult } from '../types'
 import configManager from '../infrastructure/config-manager'
 import pathManager from '../infrastructure/path-manager'
+import type { CommandResult } from '../types'
 import { getTimestamp } from '../utils/date-helper'
 
 // Re-export types for convenience
 export type {
-  ExecutionContext,
+  BlockingRules,
+  CategoryInfo,
   CommandHandler,
+  CommandMeta,
+  CommandValidationResult as ValidationResult,
+  ExecutionContext,
   HandlerFn,
   RegistryCommandUsage as CommandUsage,
-  BlockingRules,
-  CommandMeta,
-  CategoryInfo,
   RegistryStats,
-  CommandValidationResult as ValidationResult,
 } from '../types'
 
 import type {
-  ExecutionContext,
+  CategoryInfo,
   CommandHandler,
-  HandlerFn,
   CommandMeta,
-  CategoryInfo,
+  ExecutionContext,
+  HandlerFn,
   RegistryStats,
 } from '../types'
 
@@ -60,7 +60,11 @@ export class CommandRegistry {
   /**
    * Register a command handler function (function-based)
    */
-  registerFn<TParams>(name: string, handler: HandlerFn<TParams>, meta?: Partial<CommandMeta>): void {
+  registerFn<TParams>(
+    name: string,
+    handler: HandlerFn<TParams>,
+    meta?: Partial<CommandMeta>
+  ): void {
     this.handlerFns.set(name, handler as HandlerFn<unknown>)
     this.setMeta(name, meta)
   }
@@ -134,10 +138,7 @@ export class CommandRegistry {
    * Get list of registered commands
    */
   list(): string[] {
-    return [
-      ...this.handlers.keys(),
-      ...this.handlerFns.keys(),
-    ]
+    return [...this.handlers.keys(), ...this.handlerFns.keys()]
   }
 
   /**

package/core/commands/setup.ts

@@ -2,15 +2,15 @@
  * Setup Commands: start, setup, installStatusLine, showAsciiArt
  */
 
-import path from 'path'
-import fs from 'fs'
+import fs from 'node:fs'
+import path from 'node:path'
 import chalk from 'chalk'
 
 import commandInstaller from '../infrastructure/command-installer'
 import pathManager from '../infrastructure/path-manager'
 import type { CommandResult, SetupOptions } from '../types'
-import { PrjctCommandsBase } from './base'
 import { VERSION } from '../utils/version'
+import { PrjctCommandsBase } from './base'
 
 export class SetupCommands extends PrjctCommandsBase {
   /**
@@ -19,12 +19,13 @@ export class SetupCommands extends PrjctCommandsBase {
   async start(): Promise<CommandResult> {
     const aiProvider = require('../infrastructure/ai-provider')
     const activeProvider = aiProvider.getActiveProvider()
-    
+
     console.log(`🚀 Setting up prjct for ${activeProvider.displayName}...\n`)
 
     const status = await commandInstaller.checkInstallation()
 
-    if (!status.claudeDetected) { // Note: variable name is legacy, checks active provider
+    if (!status.claudeDetected) {
+      // Note: variable name is legacy, checks active provider
       return {
         success: false,
         message:
@@ -43,11 +44,15 @@ export class SetupCommands extends PrjctCommandsBase {
       }
     }
 
-    console.log(`\n✅ Installed ${result.installed?.length ?? 0} commands to:\n   ${pathManager.getDisplayPath(result.path || '')}`)
+    console.log(
+      `\n✅ Installed ${result.installed?.length ?? 0} commands to:\n   ${pathManager.getDisplayPath(result.path || '')}`
+    )
 
     if ((result.errors?.length ?? 0) > 0) {
       console.log(`\n⚠️  ${result.errors?.length ?? 0} errors:`)
-      result.errors?.forEach((e: { file: string; error: string }) => console.log(`   - ${e.file}: ${e.error}`))
+      result.errors?.forEach((e: { file: string; error: string }) =>
+        console.log(`   - ${e.file}: ${e.error}`)
+      )
     }
 
     console.log('\n🎉 Setup complete!')
@@ -87,12 +92,16 @@ export class SetupCommands extends PrjctCommandsBase {
 
     if ((result.errors?.length ?? 0) > 0) {
       console.log(`\n⚠️  ${result.errors?.length ?? 0} errors:`)
-      result.errors?.forEach((e: { file: string; error: string }) => console.log(`   - ${e.file}: ${e.error}`))
+      result.errors?.forEach((e: { file: string; error: string }) =>
+        console.log(`   - ${e.file}: ${e.error}`)
+      )
     }
 
     console.log('\n📝 Installing global configuration...')
     const configResult = await commandInstaller.installGlobalConfig()
-    const displayPath = configResult.path ? pathManager.getDisplayPath(configResult.path) : 'global config'
+    const displayPath = configResult.path
+      ? pathManager.getDisplayPath(configResult.path)
+      : 'global config'
 
     if (configResult.success) {
       if (configResult.action === 'created') {
@@ -108,7 +117,7 @@ export class SetupCommands extends PrjctCommandsBase {
 
     const aiProvider = require('../infrastructure/ai-provider')
     const activeProvider = aiProvider.getActiveProvider()
-    
+
     // Status line is currently Claude-only
     if (activeProvider.name === 'claude') {
       console.log('\n⚡ Installing status line...')
@@ -211,7 +220,7 @@ echo "⚡ prjct"
 
       settings.statusLine = {
         type: 'command',
-        command: statusLinePath
+        command: statusLinePath,
       }
 
       fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2))
@@ -235,7 +244,9 @@ echo "⚡ prjct"
     console.log(chalk.bold.cyan('   ██║     ██║  ██║╚█████╔╝╚██████╗   ██║'))
     console.log(chalk.bold.cyan('   ╚═╝     ╚═╝  ╚═╝ ╚════╝  ╚═════╝   ╚═╝'))
     console.log('')
-    console.log(`   ${chalk.bold.cyan('prjct')}${chalk.magenta('/')}${chalk.green('cli')}  ${chalk.dim.white('v' + VERSION + ' installed')}`)
+    console.log(
+      `   ${chalk.bold.cyan('prjct')}${chalk.magenta('/')}${chalk.green('cli')}  ${chalk.dim.white(`v${VERSION} installed`)}`
+    )
     console.log('')
     console.log(`   ${chalk.yellow('⚡')} Ship faster with zero friction`)
     console.log(`   ${chalk.green('📝')} From idea to technical tasks in minutes`)
@@ -258,10 +269,11 @@ echo "⚡ prjct"
     console.log(chalk.dim('─────────────────────────────────────────────────'))
     console.log('')
     console.log(`  ${chalk.dim('Documentation:')} ${chalk.cyan('https://prjct.app')}`)
-    console.log(`  ${chalk.dim('Report issues:')} ${chalk.cyan('https://github.com/jlopezlira/prjct-cli/issues')}`)
+    console.log(
+      `  ${chalk.dim('Report issues:')} ${chalk.cyan('https://github.com/jlopezlira/prjct-cli/issues')}`
+    )
     console.log('')
     console.log(chalk.bold.magenta('Happy shipping! 🚀'))
     console.log('')
   }
-
 }

package/core/commands/shipping.ts

@@ -3,22 +3,14 @@
  * Write-Through Architecture: JSON → MD → Event
  */
 
-import path from 'path'
-
-import { isNotFoundError } from '../types/fs'
+import path from 'node:path'
 import memorySystem from '../agentic/memory-system'
+import { shippedStorage, stateStorage } from '../storage'
 import type { CommandResult } from '../types'
-import { detectProjectCommands } from '../utils/project-commands'
-import {
-  PrjctCommandsBase,
-  toolRegistry,
-  configManager,
-  fileHelper,
-  dateHelper,
-  out
-} from './base'
-import { stateStorage, shippedStorage } from '../storage'
+import { isNotFoundError } from '../types/fs'
 import { showNextSteps } from '../utils/next-steps'
+import { detectProjectCommands } from '../utils/project-commands'
+import { configManager, dateHelper, fileHelper, out, PrjctCommandsBase, toolRegistry } from './base'
 
 export class ShippingCommands extends PrjctCommandsBase {
   /**
@@ -93,7 +85,7 @@ export class ShippingCommands extends PrjctCommandsBase {
       // Write-through: Record shipped feature (JSON → MD → Event)
       await shippedStorage.addShipped(projectId, {
         name: featureName,
-        version: newVersion
+        version: newVersion,
       })
 
       await this.logToMemory(projectPath, 'feature_shipped', {
@@ -112,7 +104,7 @@ export class ShippingCommands extends PrjctCommandsBase {
       if (isQuickShip) {
         await memorySystem.recordWorkflow(projectId, 'quick_ship', {
           description: 'Ship without full checks',
-          feature_type: featureName.toLowerCase().includes('doc') ? 'docs' : 'other'
+          feature_type: featureName.toLowerCase().includes('doc') ? 'docs' : 'other',
         })
       }
 
@@ -213,7 +205,10 @@ export class ShippingCommands extends PrjctCommandsBase {
   /**
    * Create git commit for ship
    */
-  async _createShipCommit(feature: string, _projectPath: string): Promise<{ success: boolean; message: string }> {
+  async _createShipCommit(
+    feature: string,
+    _projectPath: string
+  ): Promise<{ success: boolean; message: string }> {
     try {
       await toolRegistry.get('Bash')!('git add .')