dotdo 0.0.2 → 0.1.0

package/cli/utils/config.ts

@@ -0,0 +1,282 @@
+/**
+ * Config Utility
+ *
+ * Loads and manages CLI configuration from various sources:
+ * - wrangler.toml / wrangler.jsonc
+ * - dotdo.config.ts
+ * - package.json (dotdo field)
+ * - environment variables
+ */
+
+import * as fs from 'fs'
+import * as path from 'path'
+
+export interface DotdoConfig {
+  // Project settings
+  name?: string
+  entryPoint?: string
+  srcDir?: string
+  outDir?: string
+
+  // Development
+  port?: number
+  host?: string
+  persist?: boolean | string
+
+  // Cloudflare settings
+  compatibilityDate?: string
+  compatibilityFlags?: string[]
+  accountId?: string
+
+  // Durable Objects
+  durableObjects?: Record<string, {
+    className: string
+    scriptName?: string
+  }>
+
+  // Bindings
+  d1Databases?: Record<string, string>
+  r2Buckets?: string[]
+  kvNamespaces?: string[]
+
+  // Deploy targets
+  deploy?: {
+    cloudflare?: boolean
+    vercel?: boolean
+    fly?: boolean
+  }
+
+  // Tunnel settings
+  tunnel?: {
+    name?: string
+    configPath?: string
+  }
+}
+
+// Default configuration
+const defaultConfig: DotdoConfig = {
+  port: 8787,
+  host: 'localhost',
+  srcDir: '.',
+  outDir: 'dist',
+  entryPoint: 'index.ts',
+  compatibilityDate: '2024-01-01',
+  compatibilityFlags: ['nodejs_compat'],
+  persist: true,
+}
+
+/**
+ * Find the project root directory
+ */
+export function findProjectRoot(startDir: string = process.cwd()): string {
+  let dir = startDir
+
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, 'package.json'))) {
+      return dir
+    }
+    dir = path.dirname(dir)
+  }
+
+  return startDir
+}
+
+/**
+ * Load wrangler configuration
+ */
+function loadWranglerConfig(projectRoot: string): Partial<DotdoConfig> {
+  const config: Partial<DotdoConfig> = {}
+
+  // Try wrangler.jsonc first
+  const jsoncPath = path.join(projectRoot, 'wrangler.jsonc')
+  if (fs.existsSync(jsoncPath)) {
+    try {
+      // Remove comments for JSON parsing
+      const content = fs.readFileSync(jsoncPath, 'utf-8')
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/\/\/.*/g, '')
+      const wrangler = JSON.parse(content)
+      return extractWranglerConfig(wrangler)
+    } catch {
+      // Ignore parse errors
+    }
+  }
+
+  // Try wrangler.toml
+  const tomlPath = path.join(projectRoot, 'wrangler.toml')
+  if (fs.existsSync(tomlPath)) {
+    try {
+      // Simple TOML parsing for basic fields
+      const content = fs.readFileSync(tomlPath, 'utf-8')
+      const lines = content.split('\n')
+
+      for (const line of lines) {
+        const match = line.match(/^(\w+)\s*=\s*["']?([^"'\n]+)["']?/)
+        if (match) {
+          const [, key, value] = match
+          if (key === 'name') config.name = value
+          if (key === 'main') config.entryPoint = value
+          if (key === 'compatibility_date') config.compatibilityDate = value
+        }
+      }
+    } catch {
+      // Ignore parse errors
+    }
+  }
+
+  return config
+}
+
+/**
+ * Extract dotdo config from wrangler format
+ */
+function extractWranglerConfig(wrangler: Record<string, unknown>): Partial<DotdoConfig> {
+  const config: Partial<DotdoConfig> = {}
+
+  if (wrangler.name) config.name = String(wrangler.name)
+  if (wrangler.main) config.entryPoint = String(wrangler.main)
+  if (wrangler.compatibility_date) config.compatibilityDate = String(wrangler.compatibility_date)
+  if (Array.isArray(wrangler.compatibility_flags)) config.compatibilityFlags = wrangler.compatibility_flags.map(String)
+
+  // Durable Objects
+  if (wrangler.durable_objects && typeof wrangler.durable_objects === 'object') {
+    const doConfig = wrangler.durable_objects as { bindings?: Array<{ name: string; class_name: string; script_name?: string }> }
+    if (Array.isArray(doConfig.bindings)) {
+      config.durableObjects = {}
+      for (const binding of doConfig.bindings) {
+        config.durableObjects[binding.name] = {
+          className: binding.class_name,
+          scriptName: binding.script_name,
+        }
+      }
+    }
+  }
+
+  return config
+}
+
+/**
+ * Load dotdo.config.ts if present
+ */
+async function loadDotdoConfig(projectRoot: string): Promise<Partial<DotdoConfig>> {
+  const configPath = path.join(projectRoot, 'dotdo.config.ts')
+
+  if (!fs.existsSync(configPath)) {
+    return {}
+  }
+
+  try {
+    // Dynamic import for TypeScript config
+    const configModule = await import(configPath)
+    return configModule.default ?? configModule
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * Load config from package.json dotdo field
+ */
+function loadPackageJsonConfig(projectRoot: string): Partial<DotdoConfig> {
+  const pkgPath = path.join(projectRoot, 'package.json')
+
+  if (!fs.existsSync(pkgPath)) {
+    return {}
+  }
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
+    return pkg.dotdo ?? {}
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * Load config from environment variables
+ */
+function loadEnvConfig(): Partial<DotdoConfig> {
+  const config: Partial<DotdoConfig> = {}
+
+  if (process.env.DOTDO_PORT) config.port = parseInt(process.env.DOTDO_PORT, 10)
+  if (process.env.DOTDO_HOST) config.host = process.env.DOTDO_HOST
+  if (process.env.CLOUDFLARE_ACCOUNT_ID) config.accountId = process.env.CLOUDFLARE_ACCOUNT_ID
+
+  return config
+}
+
+/**
+ * Load complete configuration from all sources
+ *
+ * Priority (highest to lowest):
+ * 1. Environment variables
+ * 2. dotdo.config.ts
+ * 3. package.json dotdo field
+ * 4. wrangler.toml / wrangler.jsonc
+ * 5. Default values
+ */
+export function loadConfig(projectRoot?: string): DotdoConfig {
+  const root = projectRoot ?? findProjectRoot()
+
+  const wranglerConfig = loadWranglerConfig(root)
+  const pkgConfig = loadPackageJsonConfig(root)
+  const envConfig = loadEnvConfig()
+
+  // Note: dotdo.config.ts loading is async, so we load it synchronously here
+  // For full async support, use loadConfigAsync
+
+  return {
+    ...defaultConfig,
+    ...wranglerConfig,
+    ...pkgConfig,
+    ...envConfig,
+  }
+}
+
+/**
+ * Load configuration asynchronously (includes dotdo.config.ts)
+ */
+export async function loadConfigAsync(projectRoot?: string): Promise<DotdoConfig> {
+  const root = projectRoot ?? findProjectRoot()
+
+  const wranglerConfig = loadWranglerConfig(root)
+  const pkgConfig = loadPackageJsonConfig(root)
+  const dotdoConfig = await loadDotdoConfig(root)
+  const envConfig = loadEnvConfig()
+
+  return {
+    ...defaultConfig,
+    ...wranglerConfig,
+    ...pkgConfig,
+    ...dotdoConfig,
+    ...envConfig,
+  }
+}
+
+/**
+ * Save configuration to dotdo.config.ts
+ */
+export function saveConfig(config: Partial<DotdoConfig>, projectRoot?: string): void {
+  const root = projectRoot ?? findProjectRoot()
+  const configPath = path.join(root, 'dotdo.config.ts')
+
+  const content = `/**
+ * dotdo configuration
+ * Generated by dotdo CLI
+ */
+
+import type { DotdoConfig } from 'dotdo/cli'
+
+export default ${JSON.stringify(config, null, 2)} satisfies DotdoConfig
+`
+
+  fs.writeFileSync(configPath, content, 'utf-8')
+}
+
+/**
+ * Get a specific config value
+ */
+export function getConfigValue<K extends keyof DotdoConfig>(key: K): DotdoConfig[K] {
+  const config = loadConfig()
+  return config[key]
+}

package/cli/utils/detect.ts

@@ -0,0 +1,73 @@
+/**
+ * Code vs Natural Language Detection
+ *
+ * Uses heuristics to detect whether user input is code or natural language.
+ */
+
+export function looksLikeCode(input: string): boolean {
+  const trimmed = input.trim()
+
+  // Empty or whitespace-only is not code
+  if (!trimmed) {
+    return false
+  }
+
+  // Natural language indicators - check these FIRST
+  // If input starts with common NL patterns, treat as natural language
+  const nlStarters =
+    /^(please|help|what|how|why|when|where|who|which|can|could|would|should|explain|create|list|deploy|run the)\b/i
+
+  if (nlStarters.test(trimmed)) {
+    return false
+  }
+
+  // Code patterns
+  const codePatterns = [
+    /=>/, // arrow function
+    /\breturn\s/, // return statement
+    /^\w+\.\w+\(/, // method call at start (Math.sqrt, console.log)
+    /^const\s|^let\s|^var\s/, // variable declaration
+    /^function\s/, // function declaration
+    /^async\s+function\s/, // async function declaration
+    /^class\s/, // class declaration
+    /^import\s|^export\s/, // module syntax
+    /^await\s/, // await expression
+    /`[^`]*\$\{[^}]*\}[^`]*`/, // template literal with interpolation
+    /\?\s*[^:]+\s*:/, // ternary expression
+    /===|!==|&&|\|\|/, // comparison/logical operators
+    /\.\.\./, // spread operator
+    /^\{[^}]*:[^}]*\}$/, // object literal (simple)
+    /^\[[^\]]*\]$/, // array literal
+    /^\[[^\]]*\]\.\w+\(/, // array with method call
+    /\.\w+\([^)]*\)\.\w+\(/, // chained method calls
+  ]
+
+  if (codePatterns.some((pattern) => pattern.test(trimmed))) {
+    return true
+  }
+
+  // Arithmetic expression pattern - more specific
+  // Must be primarily operators, digits, parens, and single-letter variables
+  if (/^[\w\d\s+\-*/()%^.]+$/.test(trimmed)) {
+    // Check if it has arithmetic operators
+    if (/[+\-*/]/.test(trimmed)) {
+      // Make sure it's not natural language by checking word patterns
+      const words = trimmed.split(/\s+/)
+      // If all "words" are short (1-2 chars after removing parens) or numbers, it's likely arithmetic
+      const looksArithmetic = words.every((w) => {
+        // Strip parentheses for length check
+        const stripped = w.replace(/[()]/g, '')
+        return (
+          stripped.length <= 2 ||
+          /^[\d.]+$/.test(stripped) ||
+          /^[+\-*/()%^]+$/.test(w)
+        )
+      })
+      if (looksArithmetic) {
+        return true
+      }
+    }
+  }
+
+  return false
+}

package/cli/utils/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Utils Module
+ *
+ * Exports all utility functions for CLI operations.
+ */
+
+export { Logger, Spinner, createLogger, logger, type LogLevel, type LoggerOptions } from './logger'
+export {
+  loadConfig,
+  loadConfigAsync,
+  saveConfig,
+  findProjectRoot,
+  getConfigValue,
+  type DotdoConfig,
+} from './config'

package/cli/utils/logger.ts

@@ -0,0 +1,232 @@
+/**
+ * Logger Utility
+ *
+ * Provides consistent, colorful logging for CLI operations.
+ * Supports different log levels and contexts.
+ */
+
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'success'
+
+export interface LoggerOptions {
+  level?: LogLevel
+  context?: string
+  silent?: boolean
+  colors?: boolean
+}
+
+// ANSI color codes
+const colors = {
+  reset: '\x1b[0m',
+  dim: '\x1b[2m',
+  bold: '\x1b[1m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m',
+}
+
+// Icons for different log levels
+const icons = {
+  debug: colors.gray + '[debug]' + colors.reset,
+  info: colors.blue + '[info]' + colors.reset,
+  warn: colors.yellow + '[warn]' + colors.reset,
+  error: colors.red + '[error]' + colors.reset,
+  success: colors.green + '[ok]' + colors.reset,
+}
+
+// Log level priority
+const levelPriority: Record<LogLevel, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  success: 1,
+}
+
+/**
+ * Logger class for CLI output
+ */
+export class Logger {
+  private level: LogLevel
+  private context: string
+  private silent: boolean
+  private useColors: boolean
+
+  constructor(options: LoggerOptions = {}) {
+    this.level = options.level ?? (process.env.DEBUG ? 'debug' : 'info')
+    this.context = options.context ?? ''
+    this.silent = options.silent ?? false
+    this.useColors = options.colors ?? (process.stdout.isTTY ?? false)
+  }
+
+  /**
+   * Format a message with context and level
+   */
+  private format(level: LogLevel, message: string, data?: Record<string, unknown>): string {
+    const icon = this.useColors ? icons[level] : `[${level}]`
+    const ctx = this.context ? this.useColors ? `${colors.dim}(${this.context})${colors.reset}` : `(${this.context})` : ''
+
+    let output = `${icon} ${ctx} ${message}`
+
+    if (data) {
+      const dataStr = JSON.stringify(data, null, 2)
+      output += this.useColors ? `\n${colors.dim}${dataStr}${colors.reset}` : `\n${dataStr}`
+    }
+
+    return output
+  }
+
+  /**
+   * Check if a log level should be output
+   */
+  private shouldLog(level: LogLevel): boolean {
+    return !this.silent && levelPriority[level] >= levelPriority[this.level]
+  }
+
+  /**
+   * Debug level logging
+   */
+  debug(message: string, data?: Record<string, unknown>): void {
+    if (this.shouldLog('debug')) {
+      console.log(this.format('debug', message, data))
+    }
+  }
+
+  /**
+   * Info level logging
+   */
+  info(message: string, data?: Record<string, unknown>): void {
+    if (this.shouldLog('info')) {
+      console.log(this.format('info', message, data))
+    }
+  }
+
+  /**
+   * Warning level logging
+   */
+  warn(message: string, data?: Record<string, unknown>): void {
+    if (this.shouldLog('warn')) {
+      console.warn(this.format('warn', message, data))
+    }
+  }
+
+  /**
+   * Error level logging
+   */
+  error(message: string, data?: Record<string, unknown>): void {
+    if (this.shouldLog('error')) {
+      console.error(this.format('error', message, data))
+    }
+  }
+
+  /**
+   * Success level logging
+   */
+  success(message: string, data?: Record<string, unknown>): void {
+    if (this.shouldLog('success')) {
+      console.log(this.format('success', message, data))
+    }
+  }
+
+  /**
+   * Plain output without formatting
+   */
+  log(message: string): void {
+    if (!this.silent) {
+      console.log(message)
+    }
+  }
+
+  /**
+   * Create a child logger with additional context
+   */
+  child(context: string): Logger {
+    return new Logger({
+      level: this.level,
+      context: this.context ? `${this.context}:${context}` : context,
+      silent: this.silent,
+      colors: this.useColors,
+    })
+  }
+
+  /**
+   * Create a spinner for long operations
+   */
+  spinner(message: string): Spinner {
+    return new Spinner(message, this)
+  }
+}
+
+/**
+ * Spinner for long-running operations
+ */
+export class Spinner {
+  private message: string
+  private logger: Logger
+  private frames = ['|', '/', '-', '\\']
+  private frameIndex = 0
+  private interval: ReturnType<typeof setInterval> | null = null
+
+  constructor(message: string, logger: Logger) {
+    this.message = message
+    this.logger = logger
+  }
+
+  /**
+   * Start the spinner
+   */
+  start(): void {
+    if (process.stdout.isTTY) {
+      this.interval = setInterval(() => {
+        process.stdout.write(`\r${colors.cyan}${this.frames[this.frameIndex]}${colors.reset} ${this.message}`)
+        this.frameIndex = (this.frameIndex + 1) % this.frames.length
+      }, 100)
+    } else {
+      this.logger.info(this.message)
+    }
+  }
+
+  /**
+   * Stop the spinner with success
+   */
+  succeed(message?: string): void {
+    this.stop()
+    this.logger.success(message ?? this.message)
+  }
+
+  /**
+   * Stop the spinner with failure
+   */
+  fail(message?: string): void {
+    this.stop()
+    this.logger.error(message ?? this.message)
+  }
+
+  /**
+   * Stop the spinner
+   */
+  stop(): void {
+    if (this.interval) {
+      clearInterval(this.interval)
+      this.interval = null
+      if (process.stdout.isTTY) {
+        process.stdout.write('\r' + ' '.repeat(this.message.length + 10) + '\r')
+      }
+    }
+  }
+}
+
+/**
+ * Create a new logger instance
+ */
+export function createLogger(context?: string, options?: Omit<LoggerOptions, 'context'>): Logger {
+  return new Logger({ ...options, context })
+}
+
+/**
+ * Default logger instance
+ */
+export const logger = createLogger('dotdo')

package/dist/ai/template-literals.js

@@ -106,7 +106,7 @@ function parseJSON(text) {
     }
     // Try extracting from markdown code blocks
     const codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
-    if (codeBlockMatch) {
+    if (codeBlockMatch?.[1]) {
         try {
             return JSON.parse(codeBlockMatch[1].trim());
         }
@@ -116,7 +116,7 @@ function parseJSON(text) {
     }
     // Try extracting JSON object/array from text
     const jsonMatch = text.match(/(\{[\s\S]*\}|\[[\s\S]*\])/);
-    if (jsonMatch) {
+    if (jsonMatch?.[1]) {
         try {
             return JSON.parse(jsonMatch[1]);
         }