@gokiteam/goki-dev 0.2.0

package/cli/ConfigGenerator.js

@@ -0,0 +1,304 @@
+import fs from 'fs'
+import path from 'path'
+import { execa } from 'execa'
+import { Logger } from './Logger.js'
+import { ensureDir } from './DevToolsDir.js'
+
+/**
+ * Check if the Claude CLI is available on the system
+ */
+async function isClaudeAvailable () {
+  try {
+    await execa('claude', ['--version'])
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Read a file's content, return null if not found
+ */
+function readFileOrNull (filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf-8')
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Build the analysis prompt for Claude CLI.
+ * Embeds all project files directly so Claude needs 0 tool calls (single-shot).
+ */
+function buildPrompt () {
+  const projectDir = process.cwd()
+  const projectName = path.basename(projectDir)
+  const packageJson = readFileOrNull(path.join(projectDir, 'package.json'))
+  const configDev = readFileOrNull(path.join(projectDir, 'config.development'))
+  const composeFile = readFileOrNull(path.join(projectDir, 'docker-compose.yaml'))
+    || readFileOrNull(path.join(projectDir, 'docker-compose.yml'))
+  const dockerfileDev = fs.existsSync(path.join(projectDir, 'Dockerfile.dev'))
+  let schemaFiles = ''
+  const postgresDir = path.join(projectDir, 'setup', 'postgres')
+  if (fs.existsSync(postgresDir)) {
+    const sqlFiles = fs.readdirSync(postgresDir).filter(f => f.endsWith('.sql'))
+    for (const f of sqlFiles) {
+      schemaFiles += `\n--- ${f} ---\n`
+      schemaFiles += readFileOrNull(path.join(postgresDir, f)) || ''
+    }
+  }
+  return `Generate a .dev-tools/config.js file for the goki-dev CLI based on the project files below.
+
+Project name: ${projectName}
+Has Dockerfile.dev: ${dockerfileDev ? 'yes' : 'no'}
+
+## Project Files
+
+### package.json
+\`\`\`json
+${packageJson || '(not found)'}
+\`\`\`
+
+### config.development
+\`\`\`
+${configDev || '(not found)'}
+\`\`\`
+
+### docker-compose.yaml
+${composeFile
+    ? `\`\`\`yaml\n${composeFile}\`\`\``
+    : '(not found — the project needs a docker-compose.yaml)'}
+
+${schemaFiles
+    ? `### SQL Schema Files\n\`\`\`sql${schemaFiles}\n\`\`\``
+    : ''}
+
+## Config Format
+
+The .dev-tools/config.js uses ESM (export default {}) with these fields:
+
+| Field | Required | Type | Description |
+|-------|----------|------|-------------|
+| name | YES | string | Project name (use folder name) |
+| services | YES | object | Which dev-tools services to enable |
+| docker | YES | object | Docker compose override properties |
+| docker.composeFile | YES | string | Path to base docker-compose file (usually 'docker-compose.yaml') |
+| docker.dockerfile | no | string | Override Dockerfile (e.g. 'Dockerfile.dev' if it exists) |
+| docker.containerName | no | string | Override container_name |
+| docker.ports | no | object | { http: number } — external port mapping |
+| docker.volumes | no | array | Volume mounts for hot-reload (e.g. ['./src:/app/src']) |
+| docker.environment | no | object | Extra project-specific env var overrides |
+| database | no | string | PostgreSQL database name (only if project uses pg/knex) |
+| schemaPath | no | string | Path to SQL schema (required if database is set) |
+| httpProxy | no | object | { enabled: true } for inter-service traffic monitoring |
+| webhookProxy | no | object | { enabled: true, routes: {} } for webhook proxy |
+| pubsub | no | object | Pub/Sub emulator config with topics |
+
+## Environment Override Strategy
+
+The CLI auto-applies these env overrides based on enabled services:
+- redis: true → REDIS_HOST=goki-redis, RED_LOCK_HOST=goki-redis
+- pubsub: true → PUBSUB_EMULATOR_HOST=goki-pubsub-emulator:8085, PUB_SUB_KEY_FILE_NAME= (cleared)
+- firestore: true → FIRESTORE_EMULATOR_HOST=goki-firestore-emulator:8080, FIRESTORE_KEY_FILE_NAME= (cleared)
+- postgres: true → POSTGRES_HOST=goki-postgres
+- elasticsearch: true → ELASTIC_NODE=http://goki-elasticsearch:9200
+
+Only add docker.environment for vars NOT covered by the auto-mapping (e.g. MQTT_HOST, JWT_POSTGRES_REPOSITORY_HOST).
+
+## Dependency → Service Mapping
+
+From package.json dependencies:
+- pg, knex, sequelize → postgres: true, set database field
+- firebase-admin, @google-cloud/firestore → firestore: true
+- ioredis, redis, bull → redis: true
+- @google-cloud/pubsub → pubsub: true
+- @elastic/elasticsearch → elasticsearch: true
+
+## Pub/Sub Topic Detection
+
+In config.development, look for PUB_SUB_SUBSCRIPTION_* env vars.
+The value is the subscription name. The topic name = subscription minus "-{service-name}-sub" suffix.
+
+Topics with subscriptions use object format: { name: 'topicName', subscription: 'topicName-service-sub' }
+Topics without subscriptions (publish-only) use string format: 'topicName'
+
+## Port Convention
+
+Each service maps internal port 3000 to a unique external port:
+device-native:3000, device-simulator:3001, integration-apaleo:3002, core-pms:3003, core-key:3004, integration-mews:3005, integration-opera:3006
+
+## Example: Firestore project
+
+\`\`\`javascript
+export default {
+  name: 'core-key',
+  services: {
+    redis: true,
+    pubsub: true,
+    firestore: true
+  },
+  docker: {
+    composeFile: 'docker-compose.yaml',
+    dockerfile: 'Dockerfile.dev',
+    containerName: 'core-key-app',
+    ports: { http: 3004 },
+    volumes: ['./src:/app/src']
+  },
+  httpProxy: {
+    enabled: true
+  },
+  pubsub: {
+    projectId: 'tipi-development',
+    host: 'localhost',
+    port: 8085,
+    topics: [
+      'connectionCreated',
+      { name: 'keyActionRequested', subscription: 'keyActionRequested-core-key-sub' }
+    ]
+  }
+}
+\`\`\`
+
+## Example: PostgreSQL project with extra env
+
+\`\`\`javascript
+export default {
+  name: 'device-simulator',
+  database: 'device_simulator_dev',
+  schemaPath: './setup/postgres/device-simulator.sql',
+  services: {
+    redis: true,
+    pubsub: true,
+    postgres: true
+  },
+  docker: {
+    composeFile: 'docker-compose.yaml',
+    containerName: 'device-simulator-app',
+    ports: { http: 3001 },
+    volumes: ['./src:/app/src'],
+    environment: {
+      POSTGRES_DATABASE: 'device_simulator_dev',
+      MQTT_HOST: 'goki-dev-tools-backend',
+      MQTT_PORT: '8883'
+    }
+  },
+  pubsub: {
+    projectId: 'tipi-development',
+    host: 'localhost',
+    port: 8085,
+    topics: [
+      { name: 'systemOneMinuteTick', subscription: 'systemOneMinuteTick-device-simulator-sub' }
+    ]
+  }
+}
+\`\`\`
+
+## Output
+
+Output ONLY in this exact format with markers. No explanations, no markdown wrapping.
+
+---FILE:.dev-tools/config.js---
+(file content)
+---END---`
+}
+
+/**
+ * Parse Claude's output to extract file contents
+ */
+function parseGeneratedFiles (output) {
+  const files = {}
+  const filePattern = /---FILE:(.+?)---\n([\s\S]*?)---END---/g
+  let match
+  while ((match = filePattern.exec(output)) !== null) {
+    const filename = match[1].trim()
+    const content = match[2].trim()
+    files[filename] = content
+  }
+  return files
+}
+
+/**
+ * Offer to generate .dev-tools/config.js using Claude CLI.
+ * Returns true if config was generated successfully.
+ */
+export async function offerConfigGeneration () {
+  const projectDir = process.cwd()
+  const configPath = path.join(projectDir, '.dev-tools', 'config.js')
+  if (fs.existsSync(configPath)) {
+    Logger.error('.dev-tools/config.js exists but has errors. Please fix it manually.')
+    return false
+  }
+  const claudeAvailable = await isClaudeAvailable()
+  if (!claudeAvailable) {
+    Logger.warn('Claude CLI not found. Install it to auto-generate config.')
+    console.log('\n  To install: npm install -g @anthropic-ai/claude-code')
+    console.log('  Or create .dev-tools/config.js manually (see dev-tools/CLAUDE.md)\n')
+    return false
+  }
+  const inquirer = await import('inquirer')
+  const { shouldGenerate } = await inquirer.default.prompt([{
+    type: 'confirm',
+    name: 'shouldGenerate',
+    message: 'No .dev-tools/config.js found. Generate one using Claude AI?',
+    default: true
+  }])
+  if (!shouldGenerate) return false
+  console.log('\n  Running Claude CLI to analyze project...\n')
+  try {
+    const prompt = buildPrompt()
+    const subprocess = execa('claude', [
+      '-p', prompt,
+      '--output-format', 'text',
+      '--max-turns', '1'
+    ], {
+      cwd: projectDir,
+      stdin: 'ignore',
+      timeout: 120000
+    })
+    if (subprocess.stderr) {
+      subprocess.stderr.pipe(process.stderr)
+    }
+    const result = await subprocess
+    const files = parseGeneratedFiles(result.stdout)
+    if (!files['.dev-tools/config.js']) {
+      Logger.error('Claude did not generate a valid config')
+      console.log('\nRaw output:')
+      console.log(result.stdout)
+      return false
+    }
+    // Ensure .dev-tools/ directory exists
+    ensureDir(projectDir)
+    // Write generated files
+    for (const [filename, content] of Object.entries(files)) {
+      const filePath = path.join(projectDir, filename)
+      const dir = path.dirname(filePath)
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true })
+      }
+      fs.writeFileSync(filePath, content + '\n')
+    }
+    Logger.success(`Generated ${Object.keys(files).length} file(s)`)
+    console.log('\n  Generated files:')
+    for (const filename of Object.keys(files)) {
+      console.log(`    - ${filename}`)
+    }
+    console.log('\n  --- .dev-tools/config.js ---')
+    console.log(files['.dev-tools/config.js'].split('\n').map(l => '  ' + l).join('\n'))
+    console.log('  ---\n')
+    const { proceed } = await inquirer.default.prompt([{
+      type: 'confirm',
+      name: 'proceed',
+      message: 'Config looks good? Continue with start?',
+      default: true
+    }])
+    if (!proceed) {
+      console.log('\n  Edit .dev-tools/config.js and run goki-dev start again.\n')
+      return false
+    }
+    return true
+  } catch (error) {
+    Logger.error(`Failed to generate config: ${error.message}`)
+    return false
+  }
+}

package/cli/ConfigManager.js

@@ -0,0 +1,46 @@
+import fs from 'fs'
+import { ensureDir, getPath } from './DevToolsDir.js'
+
+const LOCAL_FILE = 'local.json'
+
+export class ConfigManager {
+  static getConfigPath (projectDir) {
+    return getPath(projectDir || process.cwd(), LOCAL_FILE)
+  }
+
+  static load (projectDir) {
+    const dir = projectDir || process.cwd()
+    const configPath = this.getConfigPath(dir)
+    if (!fs.existsSync(configPath)) {
+      return {}
+    }
+    try {
+      const content = fs.readFileSync(configPath, 'utf-8')
+      return JSON.parse(content)
+    } catch {
+      return {}
+    }
+  }
+
+  static save (config, projectDir) {
+    const dir = projectDir || process.cwd()
+    ensureDir(dir)
+    const configPath = this.getConfigPath(dir)
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n')
+  }
+
+  static getMcpPreference (projectDir) {
+    const config = this.load(projectDir)
+    return config.mcpPermissions?.prompted ? config.mcpPermissions : null
+  }
+
+  static saveMcpPreference (allowed, projectDir) {
+    const config = this.load(projectDir)
+    config.mcpPermissions = {
+      prompted: true,
+      allowed,
+      promptedAt: new Date().toISOString()
+    }
+    this.save(config, projectDir)
+  }
+}

package/cli/DatabaseManager.js

@@ -0,0 +1,94 @@
+import pg from 'pg'
+import fs from 'fs/promises'
+
+const { Client } = pg
+
+export class DatabaseManager {
+  constructor ({ host, port, user, password, database }) {
+    this.config = { host, port, user, password }
+    this.database = database
+  }
+
+  async isReachable (maxRetries = 5, delayMs = 2000) {
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        const client = new Client({ ...this.config, database: 'postgres' })
+        await client.connect()
+        await client.end()
+        return true
+      } catch (error) {
+        if (attempt === maxRetries) {
+          // Log the actual error on final attempt
+          console.error(`PostgreSQL connection failed after ${maxRetries} attempts:`, error.message)
+          return false
+        }
+        // Wait before retrying
+        await new Promise(resolve => setTimeout(resolve, delayMs))
+      }
+    }
+    return false
+  }
+
+  async databaseExists () {
+    const client = new Client({ ...this.config, database: 'postgres' })
+    await client.connect()
+    const result = await client.query(
+      'SELECT 1 FROM pg_database WHERE datname = $1',
+      [this.database]
+    )
+    await client.end()
+    return result.rows.length > 0
+  }
+
+  async createDatabase () {
+    const client = new Client({ ...this.config, database: 'postgres' })
+    await client.connect()
+    await client.query(`CREATE DATABASE "${this.database}"`)
+    await client.end()
+  }
+
+  async dropDatabase () {
+    const client = new Client({ ...this.config, database: 'postgres' })
+    await client.connect()
+    await client.query(`DROP DATABASE IF EXISTS "${this.database}"`)
+    await client.end()
+  }
+
+  async runSchema (schemaPath) {
+    const sql = await fs.readFile(schemaPath, 'utf8')
+    const client = new Client({ ...this.config, database: this.database })
+    await client.connect()
+    await client.query(sql)
+    await client.end()
+  }
+
+  async verify () {
+    const client = new Client({ ...this.config, database: this.database })
+    await client.connect()
+    const result = await client.query(`
+      SELECT
+        (SELECT COUNT(*) FROM information_schema.tables
+         WHERE table_schema = 'public' AND table_type = 'BASE TABLE') as tables,
+        (SELECT COUNT(*) FROM information_schema.views
+         WHERE table_schema = 'public') as views,
+        (SELECT COUNT(*) FROM information_schema.routines
+         WHERE routine_schema = 'public' AND routine_type = 'FUNCTION') as functions
+    `)
+    await client.end()
+    const { tables, views, functions } = result.rows[0]
+    return { tables: parseInt(tables), views: parseInt(views), functions: parseInt(functions) }
+  }
+
+  async clear () {
+    const client = new Client({ ...this.config, database: this.database })
+    await client.connect()
+    const result = await client.query(`
+      SELECT tablename FROM pg_tables
+      WHERE schemaname = 'public'
+    `)
+    for (const row of result.rows) {
+      await client.query(`TRUNCATE TABLE "${row.tablename}" CASCADE`)
+    }
+    await client.end()
+  }
+}

package/cli/DevToolsChecker.js

@@ -0,0 +1,21 @@
+import chalk from 'chalk'
+
+export class DevToolsChecker {
+  static async isRunning () {
+    try {
+      const response = await fetch('http://localhost:9000/v1/health/readiness')
+      return response.ok
+    } catch {
+      return false
+    }
+  }
+
+  static showStartInstructions () {
+    console.log('\n📦 Dev-tools is not running.\n')
+    console.log('To start dev-tools (Pub/Sub, MQTT, Redis, PostgreSQL):')
+    console.log(chalk.cyan('\n  cd ../dev-tools'))
+    console.log(chalk.cyan('  docker-compose -f docker-compose.services.yml up -d'))
+    console.log(chalk.cyan('  docker-compose -f docker-compose.dev.yml up -d\n'))
+    console.log('Then try again.\n')
+  }
+}

package/cli/DevToolsDir.js

@@ -0,0 +1,66 @@
+import fs from 'fs'
+import path from 'path'
+
+const DIR_NAME = '.dev-tools'
+const CONFIG_FILE = 'config.js'
+
+/**
+ * Ensure the .dev-tools/ directory exists in the project
+ */
+export function ensureDir (projectDir) {
+  const dirPath = path.join(projectDir, DIR_NAME)
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true })
+  }
+  return dirPath
+}
+
+/**
+ * Get the full path to a file inside .dev-tools/
+ */
+export function getPath (projectDir, filename) {
+  return path.join(projectDir, DIR_NAME, filename)
+}
+
+/**
+ * Check if .dev-tools/config.js exists
+ */
+export function configExists (projectDir) {
+  return fs.existsSync(path.join(projectDir, DIR_NAME, CONFIG_FILE))
+}
+
+/**
+ * Load the config from .dev-tools/config.js via dynamic import
+ * Returns the default export
+ */
+export async function loadConfig (projectDir) {
+  const configPath = path.join(projectDir, DIR_NAME, CONFIG_FILE)
+  if (!fs.existsSync(configPath)) return null
+  const config = await import(configPath)
+  return config.default
+}
+
+/**
+ * Ensure .dev-tools/ is in the project's .gitignore
+ */
+export function ensureGitignore (projectDir) {
+  const gitignorePath = path.join(projectDir, '.gitignore')
+  if (!fs.existsSync(gitignorePath)) return
+  const content = fs.readFileSync(gitignorePath, 'utf-8')
+  const lines = content.split('\n')
+  const patterns = [DIR_NAME + '/', '.mcp.json']
+  const toAdd = []
+  for (const pattern of patterns) {
+    const alreadyIgnored = lines.some(line => {
+      const trimmed = line.trim()
+      return trimmed === pattern || trimmed === `/${pattern}`
+    })
+    if (!alreadyIgnored) {
+      toAdd.push(pattern)
+    }
+  }
+  if (toAdd.length === 0) return
+  const endsWithNewline = content.endsWith('\n')
+  const separator = endsWithNewline ? '' : '\n'
+  fs.appendFileSync(gitignorePath, `${separator}${toAdd.join('\n')}\n`)
+}