prjct-cli 0.4.0

package/core/workflow-engine.js

@@ -0,0 +1,213 @@
+/**
+ * Workflow Engine
+ * Orchestrates adaptive agent workflows based on project capabilities
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+const capabilities = require('./project-capabilities')
+const rules = require('./workflow-rules')
+
+class WorkflowEngine {
+  /**
+   * Initialize workflow for task
+   * @param {string} task - Task description
+   * @param {string} type - Workflow type (ui, api, bug, refactor, feature)
+   * @param {string} dataPath - Project data path
+   * @returns {Promise<Object>} Workflow object
+   */
+  async init(task, type, dataPath) {
+    // Detect project capabilities
+    const projectPath = path.dirname(path.dirname(dataPath))
+    const caps = await capabilities.detect(projectPath)
+
+    // Get base workflow
+    const base = rules[type] || rules.ui
+
+    // Map all steps - mark for prompting if capability missing
+    const steps = base.map((s, index) => ({
+      ...s,
+      index,
+      status: 'pending',
+      skipped: false,
+      needsPrompt: !s.required && s.prompt && !caps[s.needs],
+    }))
+
+    // Track which capabilities are missing
+    const missingCapabilities = base
+      .filter(s => !s.required && s.needs && !caps[s.needs])
+      .map(s => s.needs)
+
+    const workflow = {
+      task,
+      type,
+      caps,
+      steps,
+      missingCapabilities,
+      current: 0,
+      active: true,
+      createdAt: new Date().toISOString(),
+    }
+
+    await this.save(workflow, dataPath)
+    return workflow
+  }
+
+  /**
+   * Get current step info
+   */
+  async getCurrent(dataPath) {
+    const wf = await this.load(dataPath)
+    if (!wf || !wf.active) return null
+
+    return wf.steps[wf.current]
+  }
+
+  /**
+   * Advance to next step
+   */
+  async next(dataPath) {
+    const wf = await this.load(dataPath)
+    if (!wf) return null
+
+    // Mark current step as completed
+    wf.steps[wf.current].status = 'completed'
+    wf.steps[wf.current].completedAt = new Date().toISOString()
+
+    // Move to next
+    wf.current++
+
+    // Check if workflow complete
+    if (wf.current >= wf.steps.length) {
+      wf.active = false
+      wf.completedAt = new Date().toISOString()
+      await this.save(wf, dataPath)
+      return null
+    }
+
+    // Mark next step as in progress
+    wf.steps[wf.current].status = 'in_progress'
+    wf.steps[wf.current].startedAt = new Date().toISOString()
+
+    await this.save(wf, dataPath)
+    return wf.steps[wf.current]
+  }
+
+  /**
+   * Skip current step
+   */
+  async skip(dataPath, reason = 'User skipped') {
+    const wf = await this.load(dataPath)
+    if (!wf) return null
+
+    wf.steps[wf.current].skipped = true
+    wf.steps[wf.current].status = 'skipped'
+    wf.steps[wf.current].skipReason = reason
+    wf.steps[wf.current].skippedAt = new Date().toISOString()
+
+    return await this.next(dataPath)
+  }
+
+  /**
+   * Insert installation step before current step
+   */
+  async insertInstall(dataPath, installTask) {
+    const wf = await this.load(dataPath)
+    if (!wf) return null
+
+    const currentIndex = wf.current
+
+    // Insert install task at current position
+    wf.steps.splice(currentIndex, 0, {
+      ...installTask,
+      index: currentIndex,
+      status: 'in_progress',
+      insertedAt: new Date().toISOString(),
+    })
+
+    // Reindex all subsequent steps
+    for (let i = currentIndex + 1; i < wf.steps.length; i++) {
+      wf.steps[i].index = i
+    }
+
+    await this.save(wf, dataPath)
+    return wf.steps[currentIndex]
+  }
+
+  /**
+   * Classify task type from description
+   * @param {string} text - Task description
+   * @returns {string} Workflow type
+   */
+  classify(text) {
+    const t = text.toLowerCase()
+
+    if (/button|form|modal|card|component|menu|nav|input/.test(t)) return 'ui'
+    if (/endpoint|api|service|route|controller/.test(t)) return 'api'
+    if (/bug|fix|error|issue|broken/.test(t)) return 'bug'
+    if (/refactor|improve|optimize|clean/.test(t)) return 'refactor'
+    if (/feature|functionality|module/.test(t)) return 'feature'
+
+    return 'ui' // Default
+  }
+
+  /**
+   * Get workflow status
+   */
+  async getStatus(dataPath) {
+    const wf = await this.load(dataPath)
+    if (!wf) return null
+
+    return {
+      task: wf.task,
+      type: wf.type,
+      active: wf.active,
+      current: wf.current,
+      total: wf.steps.length,
+      steps: wf.steps.map(s => ({
+        name: s.name,
+        status: s.status,
+        agent: s.agent,
+      })),
+      skipped: wf.skipped,
+    }
+  }
+
+  /**
+   * Load workflow from file
+   */
+  async load(dataPath) {
+    try {
+      const workflowPath = path.join(dataPath, 'workflow', 'state.json')
+      const content = await fs.readFile(workflowPath, 'utf8')
+      return JSON.parse(content)
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Save workflow to file
+   */
+  async save(workflow, dataPath) {
+    const workflowDir = path.join(dataPath, 'workflow')
+    await fs.mkdir(workflowDir, { recursive: true })
+
+    const workflowPath = path.join(workflowDir, 'state.json')
+    await fs.writeFile(workflowPath, JSON.stringify(workflow, null, 2))
+  }
+
+  /**
+   * Clear workflow
+   */
+  async clear(dataPath) {
+    try {
+      const workflowPath = path.join(dataPath, 'workflow', 'state.json')
+      await fs.unlink(workflowPath)
+    } catch {
+      // Ignore if doesn't exist
+    }
+  }
+}
+
+module.exports = new WorkflowEngine()

package/core/workflow-prompts.js

@@ -0,0 +1,192 @@
+/**
+ * Interactive workflow prompts for missing capabilities
+ * Asks users before skipping or installing tools
+ */
+
+class WorkflowPrompts {
+  /**
+   * Get recommendation based on detected stack
+   */
+  getRecommendation(stepName, projectInfo = {}) {
+    const recommendations = {
+      design: {
+        tools: ['Figma plugin', 'Storybook', 'Design tokens'],
+        install: 'npx storybook@latest init',
+        reason: 'Component documentation and design system',
+      },
+      test: {
+        tools: this.getTestRecommendation(projectInfo),
+        install: this.getTestInstallCommand(projectInfo),
+        reason: 'Quality assurance and regression prevention',
+      },
+      docs: {
+        tools: ['JSDoc', 'TypeDoc', 'Docusaurus'],
+        install: 'npm install -D jsdoc',
+        reason: 'API documentation and code examples',
+      },
+    }
+
+    return recommendations[stepName] || null
+  }
+
+  /**
+   * Detect test framework based on project stack
+   */
+  getTestRecommendation(projectInfo) {
+    const { framework, typescript } = projectInfo
+
+    if (framework === 'react') {
+      return typescript
+        ? ['Vitest + Testing Library', 'Jest + Testing Library']
+        : ['Jest + Testing Library', 'Vitest']
+    }
+
+    if (framework === 'vue') {
+      return ['Vitest', '@vue/test-utils']
+    }
+
+    if (framework === 'angular') {
+      return ['Jasmine + Karma', 'Jest']
+    }
+
+    // Default Node.js
+    return typescript
+      ? ['Vitest', 'Jest with ts-jest']
+      : ['Jest', 'Vitest', 'Mocha + Chai']
+  }
+
+  /**
+   * Get install command based on stack
+   */
+  getTestInstallCommand(projectInfo) {
+    const { framework, typescript } = projectInfo
+
+    if (framework === 'react') {
+      return typescript
+        ? 'npm install -D vitest @testing-library/react @testing-library/jest-dom'
+        : 'npm install -D jest @testing-library/react @testing-library/jest-dom'
+    }
+
+    if (framework === 'vue') {
+      return 'npm install -D vitest @vue/test-utils'
+    }
+
+    if (framework === 'angular') {
+      return 'npm install -D jest @types/jest ts-jest'
+    }
+
+    return typescript
+      ? 'npm install -D vitest'
+      : 'npm install -D jest'
+  }
+
+  /**
+   * Detect project stack from package.json
+   */
+  async detectStack(projectPath) {
+    const fs = require('fs').promises
+    const path = require('path')
+
+    try {
+      const pkgPath = path.join(projectPath, 'package.json')
+      const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'))
+
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies }
+
+      return {
+        framework: this.detectFramework(deps),
+        typescript: 'typescript' in deps,
+        bundler: this.detectBundler(deps),
+        runtime: this.detectRuntime(deps),
+      }
+    } catch {
+      return { framework: 'node', typescript: false }
+    }
+  }
+
+  detectFramework(deps) {
+    if ('react' in deps) return 'react'
+    if ('vue' in deps) return 'vue'
+    if ('@angular/core' in deps) return 'angular'
+    if ('next' in deps) return 'next'
+    if ('nuxt' in deps) return 'nuxt'
+    return 'node'
+  }
+
+  detectBundler(deps) {
+    if ('vite' in deps) return 'vite'
+    if ('webpack' in deps) return 'webpack'
+    if ('esbuild' in deps) return 'esbuild'
+    return null
+  }
+
+  detectRuntime(deps) {
+    if ('bun' in deps) return 'bun'
+    if ('deno' in deps) return 'deno'
+    return 'node'
+  }
+
+  /**
+   * Build prompt message for missing capability
+   */
+  async buildPrompt(step, capabilities, projectPath) {
+    const stack = await this.detectStack(projectPath)
+    const rec = this.getRecommendation(step.needs, stack)
+
+    if (!rec) {
+      return {
+        message: `⚠️  Step "${step.name}" requires ${step.needs} capability\n\nOptions:\n1. Skip this step\n2. Continue without ${step.needs}\n3. Pause workflow`,
+        options: ['skip', 'continue', 'pause'],
+        recommendation: null,
+      }
+    }
+
+    const toolsList = rec.tools.join(', ')
+
+    return {
+      message: `⚠️  Missing ${step.needs} capability for "${step.name}" step\n\n` +
+               `📋 Recommended: ${toolsList}\n` +
+               `💡 Reason: ${rec.reason}\n\n` +
+               'Options:\n' +
+               `1. Install recommended (${rec.install})\n` +
+               '2. Skip this step\n' +
+               `3. Continue without ${step.needs}\n` +
+               '4. Pause workflow',
+      options: ['install', 'skip', 'continue', 'pause'],
+      recommendation: rec,
+      stack,
+    }
+  }
+
+  /**
+   * Parse user choice from response
+   */
+  parseChoice(response) {
+    const lower = response.toLowerCase().trim()
+
+    if (lower.match(/^(1|install|yes|y)/)) return 'install'
+    if (lower.match(/^(2|skip|s)/)) return 'skip'
+    if (lower.match(/^(3|continue|c)/)) return 'continue'
+    if (lower.match(/^(4|pause|p)/)) return 'pause'
+
+    return 'skip' // Default to skip if unclear
+  }
+
+  /**
+   * Create installation task for workflow
+   */
+  createInstallTask(step, recommendation) {
+    return {
+      name: `install-${step.needs}`,
+      agent: 'devops',
+      action: `Install ${step.needs}: ${recommendation.install}`,
+      required: true,
+      type: 'install',
+      install: recommendation.install,
+      capability: step.needs,
+      reason: recommendation.reason,
+    }
+  }
+}
+
+module.exports = new WorkflowPrompts()

package/core/workflow-rules.js

@@ -0,0 +1,147 @@
+/**
+ * Workflow Rules
+ * Defines workflows by task type with capability requirements
+ */
+
+module.exports = {
+  // UI Component workflow
+  ui: [
+    {
+      name: 'design',
+      agent: 'frontend',
+      action: 'Create component design',
+      required: false,
+      needs: 'design',
+      prompt: true,
+    },
+    {
+      name: 'dev',
+      agent: 'frontend',
+      action: 'Implement component',
+      required: true,
+    },
+    {
+      name: 'test',
+      agent: 'qa',
+      action: 'Create tests',
+      required: false,
+      needs: 'test',
+      retry: 3,
+      prompt: true,
+    },
+    {
+      name: 'docs',
+      agent: 'scribe',
+      action: 'Document component',
+      required: false,
+      needs: 'docs',
+      prompt: true,
+    },
+  ],
+
+  // API Endpoint workflow
+  api: [
+    {
+      name: 'dev',
+      agent: 'backend',
+      action: 'Implement endpoint',
+      required: true,
+    },
+    {
+      name: 'test',
+      agent: 'qa',
+      action: 'Create API tests',
+      required: false,
+      needs: 'test',
+      retry: 3,
+      prompt: true,
+    },
+    {
+      name: 'docs',
+      agent: 'scribe',
+      action: 'Document API',
+      required: false,
+      needs: 'docs',
+      prompt: true,
+    },
+  ],
+
+  // Bug Fix workflow
+  bug: [
+    {
+      name: 'analyze',
+      agent: 'analyzer',
+      action: 'Analyze bug',
+      required: true,
+    },
+    {
+      name: 'fix',
+      agent: 'auto',
+      action: 'Fix bug',
+      required: true,
+    },
+    {
+      name: 'test',
+      agent: 'qa',
+      action: 'Verify fix',
+      required: false,
+      needs: 'test',
+      retry: 3,
+      prompt: true,
+    },
+  ],
+
+  // Refactor workflow
+  refactor: [
+    {
+      name: 'refactor',
+      agent: 'refactorer',
+      action: 'Refactor code',
+      required: true,
+    },
+    {
+      name: 'test',
+      agent: 'qa',
+      action: 'Verify refactor',
+      required: false,
+      needs: 'test',
+      retry: 3,
+      prompt: true,
+    },
+  ],
+
+  // Feature workflow (complete feature)
+  feature: [
+    {
+      name: 'design',
+      agent: 'architect',
+      action: 'Design feature',
+      required: false,
+      needs: 'design',
+      prompt: true,
+    },
+    {
+      name: 'dev',
+      agent: 'auto',
+      action: 'Implement feature',
+      required: true,
+    },
+    {
+      name: 'test',
+      agent: 'qa',
+      action: 'Test feature',
+      required: false,
+      needs: 'test',
+      retry: 3,
+      prompt: true,
+    },
+    {
+      name: 'docs',
+      agent: 'scribe',
+      action: 'Document feature',
+      required: false,
+      needs: 'docs',
+      prompt: true,
+    },
+  ],
+}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "prjct-cli",
+  "version": "0.4.0",
+  "description": "AI-integrated project management for indie hackers - works with Claude Code, Cursor, and Warp",
+  "main": "core/index.js",
+  "bin": {
+    "prjct": "./bin/prjct"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "install-global": "./scripts/install.sh",
+    "test": "echo 'No tests configured'",
+    "lint": "eslint \"**/*.js\" --ignore-pattern \"node_modules/**\" --ignore-pattern \"website/**\"",
+    "lint:fix": "eslint \"**/*.js\" --fix --ignore-pattern \"node_modules/**\" --ignore-pattern \"website/**\"",
+    "format": "prettier --write \"**/*.{js,jsx,ts,tsx,json,css,md}\" --config .config/.prettierrc --ignore-path .config/.prettierignore",
+    "format:check": "prettier --check \"**/*.{js,jsx,ts,tsx,json,css,md}\" --config .config/.prettierrc --ignore-path .config/.prettierignore",
+    "website:dev": "cd website && npm run dev",
+    "website:build": "cd website && npm run build",
+    "website:preview": "cd website && npm run preview",
+    "website:install": "cd website && npm install"
+  },
+  "keywords": [
+    "project-management",
+    "indie-hacker",
+    "ai-assistant",
+    "claude-code",
+    "cursor",
+    "warp",
+    "productivity"
+  ],
+  "author": "prjct.dev",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.0.0",
+    "ora": "^5.4.1",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "eslint": "^8.57.1",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-n": "^16.6.2",
+    "eslint-plugin-promise": "^6.6.0",
+    "prettier": "^3.6.2",
+    "prettier-plugin-tailwindcss": "^0.6.14",
+    "typescript": "^5.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jlopezlira/prjct-cli"
+  },
+  "bugs": {
+    "url": "https://github.com/jlopezlira/prjct-cli/issues"
+  },
+  "homepage": "https://prjct.dev",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "bin/",
+    "core/",
+    "templates/",
+    "scripts/install.sh",
+    "scripts/verify-installation.sh",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md",
+    "CLAUDE.md"
+  ],
+  "trustedDependencies": [
+    "chalk",
+    "commander",
+    "ora",
+    "prompts"
+  ]
+}