prjct-cli 0.11.5 → 0.12.1

package/core/plugin/{registry.js → registry.ts}

@@ -6,12 +6,30 @@
  * @version 1.0.0
  */
 
-const fs = require('fs').promises
-const path = require('path')
-const pathManager = require('../infrastructure/path-manager')
-const { pluginLoader } = require('./loader')
+import fs from 'fs/promises'
+import path from 'path'
+import pathManager from '../infrastructure/path-manager'
+import { pluginLoader } from './loader'
+
+type PluginSource = 'builtin' | 'global' | 'project'
+
+interface PluginMetadata {
+  name: string
+  version: string
+  description: string
+  path?: string
+  source?: PluginSource
+}
+
+interface PluginInfo extends PluginMetadata {
+  loaded: boolean
+  active: boolean
+}
 
 class PluginRegistry {
+  private availablePlugins: Map<string, PluginMetadata>
+  private initialized: boolean
+
   constructor() {
     this.availablePlugins = new Map()
     this.initialized = false
@@ -20,7 +38,7 @@ class PluginRegistry {
   /**
    * Initialize registry and discover available plugins
    */
-  async initialize() {
+  async initialize(): Promise<void> {
     if (this.initialized) return
 
     await this.discoverPlugins()
@@ -30,7 +48,7 @@ class PluginRegistry {
   /**
    * Discover all available plugins (not necessarily loaded)
    */
-  async discoverPlugins() {
+  async discoverPlugins(): Promise<void> {
     // Built-in plugins
     await this.discoverFromPath(
       path.join(__dirname, '..', 'plugins'),
@@ -46,18 +64,16 @@ class PluginRegistry {
 
   /**
    * Discover plugins from a path
-   * @param {string} dir
-   * @param {string} source
    */
-  async discoverFromPath(dir, source) {
+  async discoverFromPath(dir: string, source: PluginSource): Promise<void> {
     try {
       const entries = await fs.readdir(dir, { withFileTypes: true })
 
       for (const entry of entries) {
         try {
-          let pluginPath
+          let pluginPath: string
 
-          if (entry.isFile() && entry.name.endsWith('.js')) {
+          if (entry.isFile() && (entry.name.endsWith('.js') || entry.name.endsWith('.ts'))) {
             pluginPath = path.join(dir, entry.name)
           } else if (entry.isDirectory()) {
             pluginPath = path.join(dir, entry.name, 'index.js')
@@ -88,10 +104,8 @@ class PluginRegistry {
 
   /**
    * Read plugin metadata without fully loading
-   * @param {string} pluginPath
-   * @returns {Object|null}
    */
-  async readPluginMetadata(pluginPath) {
+  async readPluginMetadata(pluginPath: string): Promise<PluginMetadata | null> {
     try {
       const content = await fs.readFile(pluginPath, 'utf-8')
 
@@ -128,52 +142,43 @@ class PluginRegistry {
 
   /**
    * Get all available plugins
-   * @returns {Object[]}
    */
-  getAvailable() {
+  getAvailable(): PluginMetadata[] {
     return Array.from(this.availablePlugins.values())
   }
 
   /**
    * Get available plugins by source
-   * @param {string} source
-   * @returns {Object[]}
    */
-  getAvailableBySource(source) {
+  getAvailableBySource(source: PluginSource): PluginMetadata[] {
     return this.getAvailable().filter(p => p.source === source)
   }
 
   /**
    * Check if a plugin is available
-   * @param {string} name
-   * @returns {boolean}
    */
-  isAvailable(name) {
+  isAvailable(name: string): boolean {
     return this.availablePlugins.has(name)
   }
 
   /**
    * Check if a plugin is loaded
-   * @param {string} name
-   * @returns {boolean}
    */
-  isLoaded(name) {
+  isLoaded(name: string): boolean {
     return pluginLoader.getPlugin(name) !== null
   }
 
   /**
    * Get plugin info
-   * @param {string} name
-   * @returns {Object|null}
    */
-  getPluginInfo(name) {
+  getPluginInfo(name: string): PluginInfo | null {
     const available = this.availablePlugins.get(name)
     const loaded = pluginLoader.getPlugin(name)
 
     if (!available && !loaded) return null
 
     return {
-      ...(available || {}),
+      ...(available || { name, version: '1.0.0', description: '' }),
       loaded: !!loaded,
       active: loaded ? true : false
     }
@@ -181,10 +186,8 @@ class PluginRegistry {
 
   /**
    * Install a plugin (copy to global plugins)
-   * @param {string} sourcePath - Path to plugin file/directory
-   * @param {string} [name] - Optional name override
    */
-  async install(sourcePath, name = null) {
+  async install(sourcePath: string, name: string | null = null): Promise<void> {
     const globalPluginsPath = path.join(pathManager.getGlobalStoragePath(), 'plugins')
     await fs.mkdir(globalPluginsPath, { recursive: true })
 
@@ -208,9 +211,8 @@ class PluginRegistry {
 
   /**
    * Uninstall a plugin
-   * @param {string} name
    */
-  async uninstall(name) {
+  async uninstall(name: string): Promise<void> {
     const plugin = this.availablePlugins.get(name)
 
     if (!plugin) {
@@ -227,8 +229,7 @@ class PluginRegistry {
     }
 
     // Delete plugin file/directory
-    const pluginPath = plugin.path
-    const stat = await fs.stat(path.dirname(pluginPath))
+    const pluginPath = plugin.path!
 
     if (path.basename(pluginPath) === 'index.js') {
       // Directory plugin
@@ -244,10 +245,8 @@ class PluginRegistry {
 
   /**
    * Copy directory recursively
-   * @param {string} src
-   * @param {string} dest
    */
-  async copyDirectory(src, dest) {
+  async copyDirectory(src: string, dest: string): Promise<void> {
     await fs.mkdir(dest, { recursive: true })
     const entries = await fs.readdir(src, { withFileTypes: true })
 
@@ -265,9 +264,8 @@ class PluginRegistry {
 
   /**
    * Generate plugin list for display
-   * @returns {string}
    */
-  generatePluginList() {
+  generatePluginList(): string {
     const available = this.getAvailable()
 
     if (available.length === 0) {
@@ -276,14 +274,16 @@ class PluginRegistry {
 
     let output = '## Installed Plugins\n\n'
 
-    const bySource = {
+    const bySource: Record<PluginSource, PluginMetadata[]> = {
       builtin: [],
       global: [],
       project: []
     }
 
     for (const plugin of available) {
-      bySource[plugin.source].push(plugin)
+      if (plugin.source) {
+        bySource[plugin.source].push(plugin)
+      }
     }
 
     if (bySource.builtin.length > 0) {
@@ -319,7 +319,11 @@ class PluginRegistry {
 // Singleton instance
 const pluginRegistry = new PluginRegistry()
 
-module.exports = {
+export {
   PluginRegistry,
-  pluginRegistry
+  pluginRegistry,
+  PluginMetadata,
+  PluginInfo
 }
+
+export default { PluginRegistry, pluginRegistry }

package/core/plugins/{webhook.js → webhook.ts}

@@ -17,8 +17,26 @@
  * }
  */
 
-const { EventTypes } = require('../bus')
-const { HookPoints } = require('../plugin/hooks')
+import crypto from 'crypto'
+import { EventTypes } from '../bus'
+import { HookPoints } from '../plugin/hooks'
+
+interface WebhookConfig {
+  url?: string
+  events?: string[]
+  secret?: string
+}
+
+interface PluginContext {
+  config: WebhookConfig
+}
+
+interface WebhookPayload {
+  event: string
+  timestamp: string
+  source: string
+  data: unknown
+}
 
 const plugin = {
   name: 'webhook',
@@ -26,22 +44,23 @@ const plugin = {
   description: 'Send HTTP webhooks on events',
 
   // Plugin state
-  config: null,
+  config: null as WebhookConfig | null,
   enabled: false,
+  events: [] as string[],
 
   /**
    * Activate plugin
    */
-  async activate({ config }) {
-    this.config = config
+  async activate({ config }: PluginContext): Promise<void> {
+    plugin.config = config
 
     if (!config.url) {
       console.warn('[webhook] No URL configured, plugin disabled')
       return
     }
 
-    this.enabled = true
-    this.events = config.events || [
+    plugin.enabled = true
+    plugin.events = config.events || [
       EventTypes.SESSION_COMPLETED,
       EventTypes.FEATURE_SHIPPED,
       EventTypes.SNAPSHOT_CREATED
@@ -51,27 +70,27 @@ const plugin = {
   /**
    * Deactivate plugin
    */
-  async deactivate() {
-    this.enabled = false
+  async deactivate(): Promise<void> {
+    plugin.enabled = false
   },
 
   /**
    * Event handlers
    */
   events: {
-    [EventTypes.SESSION_COMPLETED]: async function(data) {
+    [EventTypes.SESSION_COMPLETED]: async function(data: unknown): Promise<void> {
       await plugin.sendWebhook('session.completed', data)
     },
 
-    [EventTypes.FEATURE_SHIPPED]: async function(data) {
+    [EventTypes.FEATURE_SHIPPED]: async function(data: unknown): Promise<void> {
       await plugin.sendWebhook('feature.shipped', data)
     },
 
-    [EventTypes.SNAPSHOT_CREATED]: async function(data) {
+    [EventTypes.SNAPSHOT_CREATED]: async function(data: unknown): Promise<void> {
       await plugin.sendWebhook('snapshot.created', data)
     },
 
-    [EventTypes.TASK_COMPLETED]: async function(data) {
+    [EventTypes.TASK_COMPLETED]: async function(data: unknown): Promise<void> {
       await plugin.sendWebhook('task.completed', data)
     }
   },
@@ -80,7 +99,7 @@ const plugin = {
    * Hook handlers
    */
   hooks: {
-    [HookPoints.AFTER_FEATURE_SHIP]: async function(data) {
+    [HookPoints.AFTER_FEATURE_SHIP]: async function(data: { feature: string; version: string; timestamp: string }): Promise<void> {
       await plugin.sendWebhook('feature.shipped', {
         feature: data.feature,
         version: data.version,
@@ -91,18 +110,16 @@ const plugin = {
 
   /**
    * Send webhook request
-   * @param {string} event - Event type
-   * @param {Object} data - Event data
    */
-  async sendWebhook(event, data) {
-    if (!this.enabled || !this.config.url) return
+  async sendWebhook(event: string, data: unknown): Promise<void> {
+    if (!plugin.enabled || !plugin.config?.url) return
 
     // Check if this event should be sent
-    if (this.config.events && !this.config.events.includes(event)) {
+    if (plugin.config.events && !plugin.config.events.includes(event)) {
       return
     }
 
-    const payload = {
+    const payload: WebhookPayload = {
       event,
       timestamp: new Date().toISOString(),
       source: 'prjct-cli',
@@ -110,22 +127,21 @@ const plugin = {
     }
 
     try {
-      const headers = {
+      const headers: Record<string, string> = {
         'Content-Type': 'application/json',
         'User-Agent': 'prjct-cli/webhook'
       }
 
       // Add signature if secret is configured
-      if (this.config.secret) {
-        const crypto = require('crypto')
+      if (plugin.config.secret) {
         const signature = crypto
-          .createHmac('sha256', this.config.secret)
+          .createHmac('sha256', plugin.config.secret)
           .update(JSON.stringify(payload))
           .digest('hex')
         headers['X-Prjct-Signature'] = `sha256=${signature}`
       }
 
-      const response = await fetch(this.config.url, {
+      const response = await fetch(plugin.config.url, {
         method: 'POST',
         headers,
         body: JSON.stringify(payload)
@@ -135,9 +151,9 @@ const plugin = {
         console.error(`[webhook] Request failed: ${response.status}`)
       }
     } catch (error) {
-      console.error(`[webhook] Error sending webhook:`, error.message)
+      console.error(`[webhook] Error sending webhook:`, (error as Error).message)
     }
   }
 }
 
-module.exports = plugin
+export default plugin

package/core/schemas/agents.ts

@@ -0,0 +1,27 @@
+/**
+ * Agents Schema
+ *
+ * Defines the structure for agents.json - specialized AI agents.
+ */
+
+export interface AgentSchema {
+  name: string
+  description: string
+  skills: string[]
+  patterns: string[]
+  filesOwned: string[]
+  successRate?: number
+  tasksCompleted?: number
+  bestFor: string[]
+  avoidFor: string[]
+}
+
+export type AgentsSchema = AgentSchema[]
+
+export const DEFAULT_AGENT: Omit<AgentSchema, 'name' | 'description'> = {
+  skills: [],
+  patterns: [],
+  filesOwned: [],
+  bestFor: [],
+  avoidFor: []
+}

package/core/schemas/analysis.ts

@@ -0,0 +1,41 @@
+/**
+ * Analysis Schema
+ *
+ * Defines the structure for analysis.json - repository analysis.
+ */
+
+export interface CodePattern {
+  name: string
+  description: string
+  location?: string
+}
+
+export interface AntiPattern {
+  issue: string
+  file: string
+  suggestion: string
+}
+
+export interface AnalysisSchema {
+  projectId: string
+  languages: string[]
+  frameworks: string[]
+  packageManager?: string
+  sourceDir?: string
+  testDir?: string
+  configFiles: string[]
+  fileCount: number
+  patterns: CodePattern[]
+  antiPatterns: AntiPattern[]
+  analyzedAt: string // ISO8601
+}
+
+export const DEFAULT_ANALYSIS: Omit<AnalysisSchema, 'projectId'> = {
+  languages: [],
+  frameworks: [],
+  configFiles: [],
+  fileCount: 0,
+  patterns: [],
+  antiPatterns: [],
+  analyzedAt: new Date().toISOString()
+}

package/core/schemas/ideas.ts

@@ -0,0 +1,83 @@
+/**
+ * Ideas Schema
+ *
+ * Defines the structure for ideas.json - idea backlog.
+ * Matches json-loader.ts types exactly.
+ */
+
+export type IdeaPriority = 'low' | 'medium' | 'high'
+export type IdeaStatus = 'pending' | 'converted' | 'completed' | 'archived'
+
+export interface ImpactEffort {
+  impact: 'high' | 'medium' | 'low'
+  effort: 'high' | 'medium' | 'low'
+}
+
+// Tech stack definition for idea specs
+export interface TechStack {
+  frontend?: string             // "Next.js 14, HeroUI"
+  backend?: string              // "Supabase (Auth, DB, RLS, Realtime)"
+  payments?: string             // "Stripe Billing"
+  ai?: string                   // "Vercel AI SDK"
+  deploy?: string               // "Vercel"
+  other?: string[]              // Additional stack items
+}
+
+// Module definition for complex ideas
+export interface IdeaModule {
+  name: string                  // "Multi-tenant"
+  description: string           // "Empresas con RLS estricto"
+}
+
+// Role definition
+export interface IdeaRole {
+  name: string                  // "SUPER_ADMIN"
+  description?: string          // "(global, impersonation)"
+}
+
+export interface IdeaSchema {
+  id: string                    // idea_xxxxxxxx
+  text: string                  // Title/summary
+  details?: string              // Expanded description
+  priority: IdeaPriority
+  status: IdeaStatus
+  tags: string[]
+  addedAt: string               // ISO8601
+  completedAt?: string          // ISO8601 if status=completed
+  convertedTo?: string          // featureId if status=converted
+  // Source documentation
+  source?: string               // "docs/technical-spec-v1.md, docs/edr-v1.md"
+  sourceFiles?: string[]        // Array of source files
+  // Enriched fields from MD
+  painPoints?: string[]         // from ### Pain Points section
+  solutions?: string[]          // from ### Solutions section
+  filesAffected?: string[]      // from **Files:** section
+  impactEffort?: ImpactEffort
+  implementationNotes?: string
+  // Technical spec fields for ZERO DATA LOSS
+  stack?: TechStack             // Tech stack definition
+  modules?: IdeaModule[]        // V1 modules list
+  roles?: IdeaRole[]            // User roles
+  risks?: string[]              // Critical risks/pitfalls
+  risksCount?: number           // "33 pitfalls documented"
+}
+
+export interface IdeasJson {
+  ideas: IdeaSchema[]
+  lastUpdated: string
+}
+
+// Legacy type for backwards compatibility
+export type IdeasSchema = IdeaSchema[]
+
+export const DEFAULT_IDEA: Omit<IdeaSchema, 'id' | 'text'> = {
+  priority: 'medium',
+  status: 'pending',
+  tags: [],
+  createdAt: new Date().toISOString()
+}
+
+export const DEFAULT_IDEAS: IdeasJson = {
+  ideas: [],
+  lastUpdated: ''
+}

package/core/schemas/index.ts

@@ -0,0 +1,73 @@
+/**
+ * Schemas Module
+ *
+ * TypeScript types and defaults for all JSON data files.
+ * These schemas define the source-of-truth for all project data.
+ *
+ * Data lives in: ~/.prjct-cli/projects/{projectId}/data/
+ * Views are generated in: ~/.prjct-cli/projects/{projectId}/views/
+ */
+
+// State (current task + queue)
+export * from './state'
+
+// Project metadata
+export * from './project'
+
+// Agents
+export * from './agents'
+
+// Ideas
+export * from './ideas'
+
+// Roadmap (features)
+export * from './roadmap'
+
+// Shipped items
+export * from './shipped'
+
+// Analysis
+export * from './analysis'
+
+// Outcomes
+export * from './outcomes'
+
+// ============================================
+// ID GENERATORS
+// ============================================
+
+function generateId(prefix: string): string {
+  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789'
+  let id = ''
+  for (let i = 0; i < 8; i++) {
+    id += chars[Math.floor(Math.random() * chars.length)]
+  }
+  return `${prefix}_${id}`
+}
+
+export const generateTaskId = (): string => generateId('task')
+export const generateFeatureId = (): string => generateId('feat')
+export const generateIdeaId = (): string => generateId('idea')
+export const generateShipId = (): string => generateId('ship')
+export const generateSessionId = (): string => generateId('sess')
+
+// ============================================
+// PATH HELPERS
+// ============================================
+
+import { join } from 'path'
+import { homedir } from 'os'
+
+export const GLOBAL_STORAGE = join(homedir(), '.prjct-cli', 'projects')
+
+export function getProjectPath(projectId: string): string {
+  return join(GLOBAL_STORAGE, projectId)
+}
+
+export function getDataPath(projectId: string): string {
+  return join(GLOBAL_STORAGE, projectId, 'data')
+}
+
+export function getViewsPath(projectId: string): string {
+  return join(GLOBAL_STORAGE, projectId, 'views')
+}

package/core/schemas/outcomes.ts

@@ -0,0 +1,22 @@
+/**
+ * Outcomes Schema
+ *
+ * Defines the structure for outcomes.json - task completion metrics.
+ */
+
+export type QualityScore = 1 | 2 | 3 | 4 | 5
+
+export interface OutcomeSchema {
+  id: string
+  taskId: string
+  description: string
+  estimatedDuration?: string
+  actualDuration: string
+  completedAsPlanned: boolean
+  qualityScore: QualityScore
+  blockers: string[]
+  agentUsed?: string
+  completedAt: string // ISO8601
+}
+
+export type OutcomesSchema = OutcomeSchema[]

package/core/schemas/project.ts

@@ -0,0 +1,26 @@
+/**
+ * Project Schema
+ *
+ * Defines the structure for project.json - project metadata.
+ */
+
+export interface ProjectSchema {
+  projectId: string
+  name: string
+  repoPath: string
+  description?: string
+  version?: string
+  techStack: string[]
+  fileCount: number
+  commitCount: number
+  createdAt: string // ISO8601
+  lastSync: string // ISO8601
+}
+
+export const DEFAULT_PROJECT: Omit<ProjectSchema, 'projectId' | 'name' | 'repoPath'> = {
+  techStack: [],
+  fileCount: 0,
+  commitCount: 0,
+  createdAt: new Date().toISOString(),
+  lastSync: new Date().toISOString()
+}