prjct-cli 0.11.5 → 0.12.0

package/core/utils/{jsonl-helper.js → jsonl-helper.ts}

@@ -1,41 +1,44 @@
-const fs = require('fs').promises
-const fsSync = require('fs')
-const readline = require('readline')
-const path = require('path')
+import fs from 'fs/promises'
+import fsSync from 'fs'
+import readline from 'readline'
+import path from 'path'
 
 /**
  * JSONL Helper - Centralized JSONL parsing and writing
  *
  * Eliminates duplicated JSONL logic across:
- * - session-manager.js (_parseJsonLines)
- * - commands.js (inline parsing)
- * - analyzer.js (inline parsing)
+ * - session-manager.ts (_parseJsonLines)
+ * - commands.ts (inline parsing)
+ * - analyzer.ts (inline parsing)
  *
  * JSONL Format: One JSON object per line, newline-separated
  * Example:
  * {"ts":"2025-10-04T14:30:00Z","type":"feature_add","name":"auth"}
  * {"ts":"2025-10-04T15:00:00Z","type":"task_start","task":"JWT"}
- *
- * @module jsonl-helper
  */
 
+interface NodeError extends Error {
+  code?: string
+}
+
+interface FileSizeWarning {
+  sizeMB: number
+  isLarge: boolean
+}
+
 /**
  * Parse JSONL content into array of objects
  * Handles malformed lines gracefully (skips them)
- *
- * @param {string} content - JSONL content
- * @returns {Array<Object>} - Array of parsed objects
  */
-function parseJsonLines(content) {
+export function parseJsonLines<T = Record<string, unknown>>(content: string): T[] {
   const lines = content.split('\n').filter((line) => line.trim())
-  const entries = []
+  const entries: T[] = []
 
   for (const line of lines) {
     try {
-      entries.push(JSON.parse(line))
-    } catch (error) {
+      entries.push(JSON.parse(line) as T)
+    } catch {
       // Skip malformed lines silently
-      // Could optionally log warning
     }
   }
 
@@ -44,26 +47,20 @@ function parseJsonLines(content) {
 
 /**
  * Convert array of objects to JSONL string
- *
- * @param {Array<Object>} objects - Array of objects to stringify
- * @returns {string} - JSONL formatted string
  */
-function stringifyJsonLines(objects) {
+export function stringifyJsonLines(objects: unknown[]): string {
   return objects.map((obj) => JSON.stringify(obj)).join('\n') + '\n'
 }
 
 /**
  * Read and parse JSONL file
- *
- * @param {string} filePath - Path to JSONL file
- * @returns {Promise<Array<Object>>} - Array of parsed objects
  */
-async function readJsonLines(filePath) {
+export async function readJsonLines<T = Record<string, unknown>>(filePath: string): Promise<T[]> {
   try {
     const content = await fs.readFile(filePath, 'utf-8')
-    return parseJsonLines(content)
+    return parseJsonLines<T>(content)
   } catch (error) {
-    if (error.code === 'ENOENT') {
+    if ((error as NodeError).code === 'ENOENT') {
       return [] // File doesn't exist, return empty array
     }
     throw error
@@ -72,12 +69,8 @@ async function readJsonLines(filePath) {
 
 /**
  * Write array of objects to JSONL file (overwrites)
- *
- * @param {string} filePath - Path to JSONL file
- * @param {Array<Object>} objects - Array of objects to write
- * @returns {Promise<void>}
  */
-async function writeJsonLines(filePath, objects) {
+export async function writeJsonLines(filePath: string, objects: unknown[]): Promise<void> {
   const content = stringifyJsonLines(objects)
   await fs.writeFile(filePath, content, 'utf-8')
 }
@@ -85,24 +78,16 @@ async function writeJsonLines(filePath, objects) {
 /**
  * Append a single object to JSONL file
  * Uses append mode for efficiency (no full file read/write)
- *
- * @param {string} filePath - Path to JSONL file
- * @param {Object} object - Object to append
- * @returns {Promise<void>}
  */
-async function appendJsonLine(filePath, object) {
+export async function appendJsonLine(filePath: string, object: unknown): Promise<void> {
   const line = JSON.stringify(object) + '\n'
   await fs.appendFile(filePath, line, 'utf-8')
 }
 
 /**
  * Append multiple objects to JSONL file
- *
- * @param {string} filePath - Path to JSONL file
- * @param {Array<Object>} objects - Objects to append
- * @returns {Promise<void>}
  */
-async function appendJsonLines(filePath, objects) {
+export async function appendJsonLines(filePath: string, objects: unknown[]): Promise<void> {
   const content = stringifyJsonLines(objects)
   await fs.appendFile(filePath, content, 'utf-8')
 }
@@ -110,29 +95,25 @@ async function appendJsonLines(filePath, objects) {
 /**
  * Filter JSONL file entries by predicate
  * Reads all entries, filters, returns matching ones
- *
- * @param {string} filePath - Path to JSONL file
- * @param {Function} predicate - Filter function (entry => boolean)
- * @returns {Promise<Array<Object>>} - Filtered entries
  */
-async function filterJsonLines(filePath, predicate) {
-  const entries = await readJsonLines(filePath)
+export async function filterJsonLines<T = Record<string, unknown>>(
+  filePath: string,
+  predicate: (entry: T) => boolean
+): Promise<T[]> {
+  const entries = await readJsonLines<T>(filePath)
   return entries.filter(predicate)
 }
 
 /**
  * Count lines in JSONL file (non-empty, parseable lines)
- *
- * @param {string} filePath - Path to JSONL file
- * @returns {Promise<number>} - Number of valid lines
  */
-async function countJsonLines(filePath) {
+export async function countJsonLines(filePath: string): Promise<number> {
   try {
     const content = await fs.readFile(filePath, 'utf-8')
     const lines = content.split('\n').filter((line) => line.trim())
     return lines.length
   } catch (error) {
-    if (error.code === 'ENOENT') {
+    if ((error as NodeError).code === 'ENOENT') {
       return 0
     }
     throw error
@@ -142,40 +123,35 @@ async function countJsonLines(filePath) {
 /**
  * Get last N entries from JSONL file
  * Efficient for large files (reads whole file but only returns last N)
- *
- * @param {string} filePath - Path to JSONL file
- * @param {number} n - Number of entries to return
- * @returns {Promise<Array<Object>>} - Last N entries
  */
-async function getLastJsonLines(filePath, n) {
-  const entries = await readJsonLines(filePath)
+export async function getLastJsonLines<T = Record<string, unknown>>(
+  filePath: string,
+  n: number
+): Promise<T[]> {
+  const entries = await readJsonLines<T>(filePath)
   return entries.slice(-n)
 }
 
 /**
  * Get first N entries from JSONL file
- *
- * @param {string} filePath - Path to JSONL file
- * @param {number} n - Number of entries to return
- * @returns {Promise<Array<Object>>} - First N entries
  */
-async function getFirstJsonLines(filePath, n) {
-  const entries = await readJsonLines(filePath)
+export async function getFirstJsonLines<T = Record<string, unknown>>(
+  filePath: string,
+  n: number
+): Promise<T[]> {
+  const entries = await readJsonLines<T>(filePath)
   return entries.slice(0, n)
 }
 
 /**
  * Merge multiple JSONL files into one array
  * Useful for reading multiple sessions
- *
- * @param {Array<string>} filePaths - Array of JSONL file paths
- * @returns {Promise<Array<Object>>} - Merged entries from all files
  */
-async function mergeJsonLines(filePaths) {
-  const allEntries = []
+export async function mergeJsonLines<T = Record<string, unknown>>(filePaths: string[]): Promise<T[]> {
+  const allEntries: T[] = []
 
   for (const filePath of filePaths) {
-    const entries = await readJsonLines(filePath)
+    const entries = await readJsonLines<T>(filePath)
     allEntries.push(...entries)
   }
 
@@ -184,11 +160,8 @@ async function mergeJsonLines(filePaths) {
 
 /**
  * Check if JSONL file is empty or doesn't exist
- *
- * @param {string} filePath - Path to JSONL file
- * @returns {Promise<boolean>} - True if empty or non-existent
  */
-async function isJsonLinesEmpty(filePath) {
+export async function isJsonLinesEmpty(filePath: string): Promise<boolean> {
   const count = await countJsonLines(filePath)
   return count === 0
 }
@@ -196,12 +169,11 @@ async function isJsonLinesEmpty(filePath) {
 /**
  * Read JSONL file with streaming (memory-efficient for large files)
  * Only reads last N lines instead of loading entire file
- *
- * @param {string} filePath - Path to JSONL file
- * @param {number} maxLines - Maximum lines to read (default: 1000)
- * @returns {Promise<Array<Object>>} - Array of parsed objects (last N lines)
  */
-async function readJsonLinesStreaming(filePath, maxLines = 1000) {
+export async function readJsonLinesStreaming<T = Record<string, unknown>>(
+  filePath: string,
+  maxLines = 1000
+): Promise<T[]> {
   try {
     const fileStream = fsSync.createReadStream(filePath)
     const rl = readline.createInterface({
@@ -209,12 +181,12 @@ async function readJsonLinesStreaming(filePath, maxLines = 1000) {
       crlfDelay: Infinity,
     })
 
-    const lines = []
+    const lines: T[] = []
 
     for await (const line of rl) {
       if (line.trim()) {
         try {
-          lines.push(JSON.parse(line))
+          lines.push(JSON.parse(line) as T)
         } catch {
           // Skip malformed lines
         }
@@ -228,7 +200,7 @@ async function readJsonLinesStreaming(filePath, maxLines = 1000) {
 
     return lines
   } catch (error) {
-    if (error.code === 'ENOENT') {
+    if ((error as NodeError).code === 'ENOENT') {
       return []
     }
     throw error
@@ -237,16 +209,13 @@ async function readJsonLinesStreaming(filePath, maxLines = 1000) {
 
 /**
  * Get file size in MB
- *
- * @param {string} filePath - Path to file
- * @returns {Promise<number>} - File size in MB
  */
-async function getFileSizeMB(filePath) {
+export async function getFileSizeMB(filePath: string): Promise<number> {
   try {
     const stats = await fs.stat(filePath)
     return stats.size / (1024 * 1024)
   } catch (error) {
-    if (error.code === 'ENOENT') {
+    if ((error as NodeError).code === 'ENOENT') {
       return 0
     }
     throw error
@@ -256,12 +225,8 @@ async function getFileSizeMB(filePath) {
 /**
  * Rotate JSONL file if it exceeds size limit
  * Moves large file to archive with timestamp
- *
- * @param {string} filePath - Path to JSONL file
- * @param {number} maxSizeMB - Maximum size in MB before rotation (default: 10)
- * @returns {Promise<boolean>} - True if rotated, false if not needed
  */
-async function rotateJsonLinesIfNeeded(filePath, maxSizeMB = 10) {
+export async function rotateJsonLinesIfNeeded(filePath: string, maxSizeMB = 10): Promise<boolean> {
   const sizeMB = await getFileSizeMB(filePath)
 
   if (sizeMB < maxSizeMB) {
@@ -286,13 +251,12 @@ async function rotateJsonLinesIfNeeded(filePath, maxSizeMB = 10) {
 /**
  * Append JSON line with automatic rotation
  * Checks file size before append and rotates if needed
- *
- * @param {string} filePath - Path to JSONL file
- * @param {Object} object - Object to append
- * @param {number} maxSizeMB - Maximum size before rotation (default: 10)
- * @returns {Promise<void>}
  */
-async function appendJsonLineWithRotation(filePath, object, maxSizeMB = 10) {
+export async function appendJsonLineWithRotation(
+  filePath: string,
+  object: unknown,
+  maxSizeMB = 10
+): Promise<void> {
   // Rotate if needed (before appending)
   await rotateJsonLinesIfNeeded(filePath, maxSizeMB)
 
@@ -303,12 +267,11 @@ async function appendJsonLineWithRotation(filePath, object, maxSizeMB = 10) {
 /**
  * Warn if file is large before reading
  * Returns size and whether it's considered large
- *
- * @param {string} filePath - Path to file
- * @param {number} warnThresholdMB - Threshold in MB to warn (default: 50)
- * @returns {Promise<{sizeMB: number, isLarge: boolean}>}
  */
-async function checkFileSizeWarning(filePath, warnThresholdMB = 50) {
+export async function checkFileSizeWarning(
+  filePath: string,
+  warnThresholdMB = 50
+): Promise<FileSizeWarning> {
   const sizeMB = await getFileSizeMB(filePath)
   const isLarge = sizeMB > warnThresholdMB
 
@@ -321,7 +284,8 @@ async function checkFileSizeWarning(filePath, warnThresholdMB = 50) {
   return { sizeMB, isLarge }
 }
 
-module.exports = {
+// Default export for CommonJS compatibility
+export default {
   parseJsonLines,
   stringifyJsonLines,
   readJsonLines,
@@ -334,10 +298,10 @@ module.exports = {
   getFirstJsonLines,
   mergeJsonLines,
   isJsonLinesEmpty,
-  // NEW: Memory-efficient functions
   readJsonLinesStreaming,
   getFileSizeMB,
   rotateJsonLinesIfNeeded,
   appendJsonLineWithRotation,
-  checkFileSizeWarning,
+  checkFileSizeWarning
 }
+

package/core/utils/{logger.js → logger.ts}

@@ -9,14 +9,26 @@
  *   PRJCT_DEBUG=debug   (everything)
  *
  * Usage:
- *   const log = require('./utils/logger')
+ *   import log from './utils/logger'
  *   log.debug('Processing files...')
  *   log.info('Task started')
  *   log.warn('Cache miss')
  *   log.error('Failed to load', error.message)
  */
 
-const LEVELS = { error: 0, warn: 1, info: 2, debug: 3 }
+type LogLevel = 'error' | 'warn' | 'info' | 'debug'
+type LogFunction = (...args: unknown[]) => void
+
+interface Logger {
+  error: LogFunction
+  warn: LogFunction
+  info: LogFunction
+  debug: LogFunction
+  isEnabled: () => boolean
+  level: () => LogLevel | 'disabled'
+}
+
+const LEVELS: Record<LogLevel, number> = { error: 0, warn: 1, info: 2, debug: 3 }
 
 const debugEnv = process.env.PRJCT_DEBUG || process.env.DEBUG || ''
 const isEnabled = debugEnv === '1' || debugEnv === 'true' || debugEnv.includes('prjct')
@@ -26,39 +38,39 @@ let currentLevel = -1 // disabled by default
 if (isEnabled) {
   if (debugEnv === '1' || debugEnv === 'true' || debugEnv === 'prjct') {
     currentLevel = LEVELS.debug // all logs
-  } else if (LEVELS[debugEnv] !== undefined) {
-    currentLevel = LEVELS[debugEnv]
+  } else if (LEVELS[debugEnv as LogLevel] !== undefined) {
+    currentLevel = LEVELS[debugEnv as LogLevel]
   } else {
     currentLevel = LEVELS.debug
   }
 }
 
 // No-op function for disabled logs
-const noop = () => {}
+const noop: LogFunction = () => {}
 
 // Create logger methods
-const logger = {
+const logger: Logger = {
   error: currentLevel >= LEVELS.error
-    ? (...args) => console.error('[prjct:error]', ...args)
+    ? (...args: unknown[]) => console.error('[prjct:error]', ...args)
     : noop,
 
   warn: currentLevel >= LEVELS.warn
-    ? (...args) => console.warn('[prjct:warn]', ...args)
+    ? (...args: unknown[]) => console.warn('[prjct:warn]', ...args)
     : noop,
 
   info: currentLevel >= LEVELS.info
-    ? (...args) => console.log('[prjct:info]', ...args)
+    ? (...args: unknown[]) => console.log('[prjct:info]', ...args)
     : noop,
 
   debug: currentLevel >= LEVELS.debug
-    ? (...args) => console.log('[prjct:debug]', ...args)
+    ? (...args: unknown[]) => console.log('[prjct:debug]', ...args)
     : noop,
 
   // Check if logging is enabled (useful for expensive log prep)
   isEnabled: () => currentLevel >= 0,
 
   // Get current level name
-  level: () => Object.keys(LEVELS).find(k => LEVELS[k] === currentLevel) || 'disabled'
+  level: () => (Object.keys(LEVELS) as LogLevel[]).find(k => LEVELS[k] === currentLevel) || 'disabled'
 }
 
-module.exports = logger
+export default logger

package/core/utils/{output.js → output.ts}

@@ -1,22 +1,34 @@
 /**
  * Minimal Output System for prjct-cli
  * Spinner while working → Single line result
- * With ⚡ prjct branding
+ * With prjct branding
  */
 
-const chalk = require('chalk')
-const branding = require('./branding')
+import chalk from 'chalk'
+import branding from './branding'
 
 const FRAMES = branding.spinner.frames
 const SPEED = branding.spinner.speed
 
-let interval = null
+let interval: ReturnType<typeof setInterval> | null = null
 let frame = 0
 
-const truncate = (s, max = 50) => (s && s.length > max ? s.slice(0, max - 1) + '…' : s || '')
-const clear = () => process.stdout.write('\r' + ' '.repeat(80) + '\r')
+const truncate = (s: string | undefined | null, max = 50): string =>
+  s && s.length > max ? s.slice(0, max - 1) + '…' : s || ''
 
-const out = {
+const clear = (): boolean => process.stdout.write('\r' + ' '.repeat(80) + '\r')
+
+interface Output {
+  start(): Output
+  end(): Output
+  spin(msg: string): Output
+  done(msg: string): Output
+  fail(msg: string): Output
+  warn(msg: string): Output
+  stop(): Output
+}
+
+const out: Output = {
   // Branding: Show header at start
   start() {
     console.log(branding.cli.header())
@@ -29,8 +41,8 @@ const out = {
     return this
   },
 
-  // Branded spinner: ⚡ prjct ⠋ message...
-  spin(msg) {
+  // Branded spinner: prjct message...
+  spin(msg: string) {
     this.stop()
     interval = setInterval(() => {
       process.stdout.write(`\r${branding.cli.spin(frame++, truncate(msg, 45))}`)
@@ -38,19 +50,19 @@ const out = {
     return this
   },
 
-  done(msg) {
+  done(msg: string) {
     this.stop()
     console.log(`${chalk.green('✓')} ${truncate(msg, 65)}`)
     return this
   },
 
-  fail(msg) {
+  fail(msg: string) {
     this.stop()
     console.log(`${chalk.red('✗')} ${truncate(msg, 65)}`)
     return this
   },
 
-  warn(msg) {
+  warn(msg: string) {
     this.stop()
     console.log(`${chalk.yellow('⚠')} ${truncate(msg, 65)}`)
     return this
@@ -66,4 +78,4 @@ const out = {
   }
 }
 
-module.exports = out
+export default out

package/core/utils/{project-capabilities.js → project-capabilities.ts}

@@ -3,16 +3,25 @@
  * Detects ONLY what exists - no assumptions, no hallucinations
  */
 
-const fs = require('fs').promises
-const path = require('path')
+import fs from 'fs/promises'
+import path from 'path'
+
+interface Capabilities {
+  design: boolean
+  test: boolean
+  docs: boolean
+}
+
+interface PackageJson {
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+}
 
 class ProjectCapabilities {
   /**
    * Detect project capabilities
-   * @param {string} projectPath - Project root path
-   * @returns {Promise<Object>} Capabilities object
    */
-  async detect(projectPath = process.cwd()) {
+  async detect(projectPath = process.cwd()): Promise<Capabilities> {
     return {
       design: await this.hasDesign(projectPath),
       test: await this.hasTest(projectPath),
@@ -23,7 +32,7 @@ class ProjectCapabilities {
   /**
    * Check if project has design system
    */
-  async hasDesign(projectPath) {
+  async hasDesign(projectPath: string): Promise<boolean> {
     return (
       (await this.hasFolder(projectPath, 'design')) ||
       (await this.hasFolder(projectPath, 'designs')) ||
@@ -37,7 +46,7 @@ class ProjectCapabilities {
   /**
    * Check if project has test framework
    */
-  async hasTest(projectPath) {
+  async hasTest(projectPath: string): Promise<boolean> {
     return (
       (await this.hasDep(projectPath, 'jest')) ||
       (await this.hasDep(projectPath, 'vitest')) ||
@@ -52,7 +61,7 @@ class ProjectCapabilities {
   /**
    * Check if project has documentation system
    */
-  async hasDocs(projectPath) {
+  async hasDocs(projectPath: string): Promise<boolean> {
     return (
       (await this.hasFolder(projectPath, 'docs')) ||
       (await this.hasFolder(projectPath, 'documentation')) ||
@@ -65,7 +74,7 @@ class ProjectCapabilities {
   /**
    * Check if folder exists
    */
-  async hasFolder(projectPath, folderName) {
+  async hasFolder(projectPath: string, folderName: string): Promise<boolean> {
     try {
       const folderPath = path.join(projectPath, folderName)
       const stat = await fs.stat(folderPath)
@@ -78,7 +87,7 @@ class ProjectCapabilities {
   /**
    * Check if file exists
    */
-  async hasFile(projectPath, fileName) {
+  async hasFile(projectPath: string, fileName: string): Promise<boolean> {
     try {
       const filePath = path.join(projectPath, fileName)
       await fs.access(filePath)
@@ -91,7 +100,7 @@ class ProjectCapabilities {
   /**
    * Check if files matching pattern exist
    */
-  async hasFiles(projectPath, pattern) {
+  async hasFiles(projectPath: string, pattern: string): Promise<boolean> {
     try {
       // Convert glob pattern to regex
       const regex = this.globToRegex(pattern)
@@ -99,9 +108,12 @@ class ProjectCapabilities {
 
       // Filter by pattern and ignore node_modules, dist, build
       return files.some((file) => {
+        const fileName = typeof file === 'string' ? file : file.toString()
         const skip =
-          file.includes('node_modules/') || file.includes('dist/') || file.includes('build/')
-        return !skip && regex.test(file)
+          fileName.includes('node_modules/') ||
+          fileName.includes('dist/') ||
+          fileName.includes('build/')
+        return !skip && regex.test(fileName)
       })
     } catch {
       return false
@@ -111,24 +123,24 @@ class ProjectCapabilities {
   /**
    * Convert simple glob pattern to regex
    */
-  globToRegex(pattern) {
+  globToRegex(pattern: string): RegExp {
     // Convert **/*.{test,spec}.{js,ts,jsx,tsx} to regex
     const escaped = pattern
       .replace(/\./g, '\\.')
       .replace(/\*\*/g, '.*')
       .replace(/\*/g, '[^/]*')
-      .replace(/\{([^}]+)\}/g, (_, group) => `(${group.split(',').join('|')})`)
+      .replace(/\{([^}]+)\}/g, (_, group: string) => `(${group.split(',').join('|')})`)
     return new RegExp(escaped)
   }
 
   /**
    * Check if dependency exists in package.json
    */
-  async hasDep(projectPath, depName) {
+  async hasDep(projectPath: string, depName: string): Promise<boolean> {
     try {
       const pkgPath = path.join(projectPath, 'package.json')
       const content = await fs.readFile(pkgPath, 'utf8')
-      const pkg = JSON.parse(content)
+      const pkg: PackageJson = JSON.parse(content)
 
       return !!(
         (pkg.dependencies && pkg.dependencies[depName]) ||
@@ -140,4 +152,5 @@ class ProjectCapabilities {
   }
 }
 
-module.exports = new ProjectCapabilities()
+const projectCapabilities = new ProjectCapabilities()
+export default projectCapabilities