@exreve/exk 1.0.0

package/skills/index.ts

@@ -0,0 +1,151 @@
+import { readFileSync, readdirSync, existsSync } from 'fs'
+import * as path from 'path'
+import { fileURLToPath } from 'url'
+import { dirname } from 'path'
+
+export interface Skill {
+  name: string
+  description: string
+  content: string
+}
+
+const SKILLS_DIR = dirname(fileURLToPath(import.meta.url)) // This file is in the skills directory
+
+const skillCache = new Map<string, Skill>()
+
+/**
+ * Parse frontmatter and content from a skill markdown file
+ */
+function parseSkillFile(content: string): { name: string; description: string; content: string } | null {
+  // Check for YAML frontmatter between --- markers
+  const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/
+  const match = content.match(frontmatterRegex)
+
+  if (!match) {
+    // No frontmatter, use filename as name
+    return null
+  }
+
+  const frontmatter = match[1]
+  const skillContent = match[2].trim()
+
+  // Parse name and description from frontmatter
+  const nameMatch = frontmatter.match(/name:\s*(.+)/)
+  const descriptionMatch = frontmatter.match(/description:\s*(.+)/)
+
+  const name = nameMatch ? nameMatch[1].trim() : ''
+  const description = descriptionMatch ? descriptionMatch[1].trim() : ''
+
+  if (!name) {
+    return null
+  }
+
+  return { name, description, content: skillContent }
+}
+
+/**
+ * Load a single skill by name
+ */
+export function loadSkill(name: string): Skill | null {
+  // Check cache first
+  if (skillCache.has(name)) {
+    return skillCache.get(name)!
+  }
+
+  const skillPath = path.join(SKILLS_DIR, `${name}.md`)
+
+  if (!existsSync(skillPath)) {
+    return null
+  }
+
+  try {
+    const content = readFileSync(skillPath, 'utf-8')
+    const parsed = parseSkillFile(content)
+
+    if (!parsed) {
+      return null
+    }
+
+    const skill: Skill = {
+      name: parsed.name,
+      description: parsed.description,
+      content: parsed.content
+    }
+
+    skillCache.set(name, skill)
+    return skill
+  } catch (error) {
+    console.error(`Failed to load skill ${name}:`, error)
+    return null
+  }
+}
+
+/**
+ * Load all available skills from the skills directory
+ */
+export function loadAllSkills(): Skill[] {
+  const skills: Skill[] = []
+
+  if (!existsSync(SKILLS_DIR)) {
+    return skills
+  }
+
+  try {
+    const files = readdirSync(SKILLS_DIR)
+
+    for (const file of files) {
+      if (!file.endsWith('.md')) {
+        continue
+      }
+
+      const name = file.replace('.md', '')
+      const skill = loadSkill(name)
+
+      if (skill) {
+        skills.push(skill)
+      }
+    }
+  } catch (error) {
+    console.error('Failed to load skills:', error)
+  }
+
+  return skills
+}
+
+/**
+ * Get skill content for injection into prompts
+ */
+export function getSkillContent(names: string[]): string {
+  if (names.length === 0) {
+    return ''
+  }
+
+  const contents: string[] = []
+
+  for (const name of names) {
+    const skill = loadSkill(name)
+    if (skill) {
+      contents.push(`# Skill: ${skill.name}\n\n${skill.content}`)
+    }
+  }
+
+  if (contents.length === 0) {
+    return ''
+  }
+
+  return `## Active Skills\n\n${contents.join('\n\n---\n\n')}\n\n---\n\n`
+}
+
+/**
+ * List all available skill names
+ */
+export function listSkillNames(): string[] {
+  return loadAllSkills().map(s => s.name)
+}
+
+/**
+ * Get skill metadata (name, description) for all skills
+ */
+export function getSkillMetadata(): Array<{ name: string; description: string }> {
+  return loadAllSkills().map(s => ({ name: s.name, description: s.description }))
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "node",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "types": ["node"],
+    "downlevelIteration": true
+  },
+  "include": ["*.ts", "shared/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/updater.ts

@@ -0,0 +1,512 @@
+#!/usr/bin/env node
+/**
+ * TalkToCode CLI Updater - Standalone Update Process
+ *
+ * This is a minimal, robust updater that:
+ * 1. Runs as the main process
+ * 2. Spawns the app as a child process
+ * 3. Can update itself even if app is corrupted
+ * 4. Can recover from failed updates
+ *
+ * Architecture:
+ * - updater.ts (this file) -> Main process, handles updates
+ * - app-child.ts -> Child process, contains all app logic
+ *
+ * File structure:
+ * - ttc (updater) -> Main entry point
+ * - ttc-app.js -> Child bundle (updated via updates)
+ * - ttc-app.js.old -> Backup of last version
+ * - ttc-app.js.backup -> Secondary backup
+ */
+
+import { spawn, ChildProcess } from 'child_process'
+import fs from 'fs/promises'
+import fsSync from 'fs'
+import path from 'path'
+import os from 'os'
+import crypto from 'crypto'
+import { fileURLToPath } from 'url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const CONFIG_DIR = path.join(os.homedir(), '.talk-to-code')
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json')
+const DEVICE_ID_FILE = path.join(CONFIG_DIR, 'device-id.json')
+
+// File paths
+const UPDATER_FILE = fileURLToPath(import.meta.url)
+const APP_BUNDLE = path.join(__dirname, 'dist', 'app-child.js')
+const APP_BUNDLE_BACKUP = APP_BUNDLE + '.backup'
+const APP_BUNDLE_OLD = APP_BUNDLE + '.old'
+const BUNDLE_HASHES_FILE = path.join(__dirname, 'binary-hashes.json')
+const UPDATE_LOCK_FILE = path.join(CONFIG_DIR, '.update-lock')
+
+// State
+let childProcess: ChildProcess | null = null
+let isUpdating = false
+let restartRequested = false
+
+// ============ Configuration ============
+
+interface Config {
+  apiUrl: string
+}
+
+async function readConfig(): Promise<Config> {
+  try {
+    const data = await fs.readFile(CONFIG_FILE, 'utf-8')
+    return JSON.parse(data)
+  } catch {
+    return { apiUrl: 'https://api.talk-to-code.com' }
+  }
+}
+
+// ============ Hash Utilities ============
+
+function calculateHash(filePath: string): string {
+  try {
+    const fileData = fsSync.readFileSync(filePath)
+    return crypto.createHash('sha256').update(fileData).digest('hex')
+  } catch {
+    return ''
+  }
+}
+
+async function getBundleHashes(): Promise<Record<string, any>> {
+  try {
+    const data = await fs.readFile(BUNDLE_HASHES_FILE, 'utf-8')
+    return JSON.parse(data)
+  } catch {
+    return {}
+  }
+}
+
+// ============ Update System ============
+
+interface UpdateInfo {
+  updateAvailable: boolean
+  downloadUrl?: string
+  hash?: string
+  version?: string
+  changelog?: string
+  size?: number
+}
+
+async function checkForUpdates(): Promise<UpdateInfo | null> {
+  try {
+    const config = await readConfig()
+    const currentHash = calculateHash(APP_BUNDLE)
+
+    if (!currentHash) {
+      console.warn('⚠️  Cannot calculate current bundle hash')
+      return null
+    }
+
+    const response = await fetch(`${config.apiUrl}/update/check`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        hash: currentHash,
+        platform: os.platform(),
+        arch: os.arch()
+      })
+    })
+
+    if (!response.ok) {
+      console.warn(`⚠️  Update check failed: HTTP ${response.status}`)
+      return null
+    }
+
+    const info = await response.json() as UpdateInfo
+    return info
+  } catch (error: any) {
+    console.warn(`⚠️  Update check failed: ${error.message}`)
+    return null
+  }
+}
+
+async function downloadUpdate(downloadUrl: string, expectedHash: string): Promise<Buffer> {
+  console.log('📥 Downloading update...')
+
+  const response = await fetch(downloadUrl)
+  if (!response.ok) {
+    throw new Error(`Download failed: HTTP ${response.status}`)
+  }
+
+  const buffer = Buffer.from(await response.arrayBuffer())
+  const actualHash = crypto.createHash('sha256').update(buffer).digest('hex')
+
+  if (actualHash !== expectedHash) {
+    throw new Error(`Hash mismatch: expected ${expectedHash}, got ${actualHash}`)
+  }
+
+  console.log('✓ Download verified')
+  return buffer
+}
+
+async function applyUpdate(newBundle: Buffer): Promise<void> {
+  console.log('🔄 Applying update...')
+
+  // Create backup of current version if it exists
+  if (fsSync.existsSync(APP_BUNDLE)) {
+    try {
+      // Rotate backups: .old -> .backup (if exists), current -> .old
+      if (fsSync.existsSync(APP_BUNDLE_OLD)) {
+        await fs.copyFile(APP_BUNDLE_OLD, APP_BUNDLE_BACKUP)
+      }
+      await fs.copyFile(APP_BUNDLE, APP_BUNDLE_OLD)
+      console.log('✓ Backup created')
+    } catch (error: any) {
+      console.warn(`⚠️  Backup creation failed: ${error.message}`)
+    }
+  }
+
+  // Write new bundle
+  const tempPath = path.join(os.tmpdir(), `ttc-update-${Date.now()}.js`)
+  await fs.writeFile(tempPath, newBundle, { mode: 0o755 })
+
+  // Replace current bundle
+  await fs.rename(tempPath, APP_BUNDLE)
+
+  // Make executable
+  if (process.platform !== 'win32') {
+    await fs.chmod(APP_BUNDLE, 0o755)
+  }
+
+  console.log('✓ Update applied')
+}
+
+async function performUpdate(info: UpdateInfo): Promise<boolean> {
+  if (!info.downloadUrl || !info.hash) {
+    console.error('❌ Invalid update info')
+    return false
+  }
+
+  try {
+    const newBundle = await downloadUpdate(info.downloadUrl, info.hash)
+    await applyUpdate(newBundle)
+
+    if (info.version) {
+      console.log(`✓ Updated to version ${info.version}`)
+    }
+    if (info.changelog) {
+      console.log(`\n📝 Changelog:\n${info.changelog}`)
+    }
+
+    return true
+  } catch (error: any) {
+    console.error(`❌ Update failed: ${error.message}`)
+
+    // Attempt rollback
+    if (fsSync.existsSync(APP_BUNDLE_OLD)) {
+      console.log('🔄 Rolling back to previous version...')
+      try {
+        await fs.copyFile(APP_BUNDLE_OLD, APP_BUNDLE)
+        console.log('✓ Rollback complete')
+      } catch (rollbackError: any) {
+        console.error(`❌ Rollback failed: ${rollbackError.message}`)
+      }
+    }
+
+    return false
+  }
+}
+
+// ============ Child Process Management ============
+
+function spawnChild(): ChildProcess {
+  if (!fsSync.existsSync(APP_BUNDLE)) {
+    console.error(`❌ App bundle not found: ${APP_BUNDLE}`)
+    console.error('Please run: npm run build:cli')
+    process.exit(1)
+  }
+
+  console.log(`🚀 Spawning child process: ${APP_BUNDLE}`)
+
+  const child = spawn(process.execPath, [APP_BUNDLE, ...process.argv.slice(2)], {
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      TTC_IS_CHILD: '1',
+      TTC_UPDATER_PID: process.pid.toString()
+    }
+  })
+
+  child.on('exit', (code, signal) => {
+    console.log(`\n📦 Child process exited (code: ${code}, signal: ${signal})`)
+    childProcess = null
+
+    // If update was requested, restart with new version
+    if (restartRequested) {
+      console.log('🔄 Restarting with updated version...')
+      restartRequested = false
+      childProcess = spawnChild()
+      return
+    }
+
+    // If child crashed, try to recover
+    if (code !== 0 && code !== null && !isUpdating) {
+      console.log('⚠️  Child process crashed, attempting recovery...')
+
+      // Try backup version if current is corrupted
+      if (fsSync.existsSync(APP_BUNDLE_OLD)) {
+        console.log('🔄 Attempting to recover with backup...')
+        fs.copyFile(APP_BUNDLE_OLD, APP_BUNDLE)
+          .then(() => {
+            console.log('✓ Recovered, restarting...')
+            childProcess = spawnChild()
+          })
+          .catch((err) => {
+            console.error('❌ Recovery failed, giving up')
+            process.exit(1)
+          })
+      } else {
+        console.error('❌ No backup available, cannot recover')
+        process.exit(1)
+      }
+    } else if (signal !== 'SIGTERM' && signal !== 'SIGINT') {
+      // Normal exit or intentional signal
+      process.exit(code || 0)
+    }
+  })
+
+  child.on('error', (error) => {
+    console.error('❌ Child process error:', error)
+    childProcess = null
+  })
+
+  return child
+}
+
+// ============ Signal Handling ============
+
+function setupSignalHandlers() {
+  // Forward signals to child
+  const signals = ['SIGINT', 'SIGTERM', 'SIGHUP', 'SIGUSR1', 'SIGUSR2']
+
+  signals.forEach(signal => {
+    process.on(signal as NodeJS.Signals, () => {
+      if (childProcess) {
+        console.log(`\n📡 Forwarding ${signal} to child process...`)
+        childProcess.kill(signal as NodeJS.Signals)
+      } else {
+        process.exit(0)
+      }
+    })
+  })
+
+  // Handle uncaught exceptions
+  process.on('uncaughtException', (error) => {
+    console.error('❌ Uncaught exception in updater:', error)
+    if (childProcess) {
+      childProcess.kill('SIGTERM')
+    }
+    process.exit(1)
+  })
+
+  process.on('unhandledRejection', (reason, promise) => {
+    console.error('❌ Unhandled rejection in updater:', reason)
+  })
+}
+
+// ============ CLI Interface ============
+
+async function cmdUpdate(): Promise<void> {
+  console.log('🔍 Checking for updates...')
+
+  const info = await checkForUpdates()
+
+  if (!info) {
+    console.log('⚠️  Unable to check for updates')
+    process.exit(1)
+    return
+  }
+
+  if (!info.updateAvailable) {
+    console.log('✓ Already up to date')
+    process.exit(0)
+    return
+  }
+
+  console.log('📦 Update available!')
+  if (info.version) {
+    console.log(`   Version: ${info.version}`)
+  }
+  if (info.changelog) {
+    console.log(`\n📝 Changelog:\n${info.changelog}`)
+  }
+
+  // Stop child process if running
+  if (childProcess) {
+    console.log('🛑 Stopping child process...')
+    childProcess.kill('SIGTERM')
+    childProcess = null
+  }
+
+  isUpdating = true
+  const success = await performUpdate(info)
+  isUpdating = false
+
+  if (success) {
+    console.log('\n✓ Update complete! Restarting...')
+    restartRequested = true
+    childProcess = spawnChild()
+  } else {
+    console.error('\n❌ Update failed!')
+    process.exit(1)
+  }
+}
+
+async function cmdUpdateCheck(): Promise<void> {
+  console.log('🔍 Checking for updates...')
+
+  const info = await checkForUpdates()
+
+  if (!info) {
+    console.log('⚠️  Unable to check for updates')
+    process.exit(1)
+    return
+  }
+
+  if (info.updateAvailable) {
+    console.log('📦 Update available!')
+    if (info.version) {
+      console.log(`   Version: ${info.version}`)
+    }
+    if (info.size) {
+      console.log(`   Size: ${(info.size / 1024 / 1024).toFixed(2)} MB`)
+    }
+    if (info.changelog) {
+      console.log(`\n📝 Changelog:\n${info.changelog}`)
+    }
+    console.log('\nRun "ttc update" to apply the update')
+    process.exit(0)
+  } else {
+    console.log('✓ Already up to date')
+    process.exit(0)
+  }
+}
+
+async function cmdVersion(): Promise<void> {
+  console.log(`TalkToCode CLI Updater`)
+  console.log(`Node: ${process.version}`)
+  console.log(`Platform: ${os.platform()} ${os.arch()}`)
+
+  const currentHash = calculateHash(APP_BUNDLE)
+  console.log(`Bundle hash: ${currentHash ? currentHash.substring(0, 16) + '...' : 'unknown'}`)
+
+  const hashes = await getBundleHashes()
+  if (hashes['js-bundle']) {
+    console.log(`Bundle version: ${hashes['js-bundle'].version || 'unknown'}`)
+    console.log(`Bundle date: ${hashes['js-bundle'].date || 'unknown'}`)
+  }
+
+  process.exit(0)
+}
+
+// ============ IPC from Child Process ============
+
+/**
+ * The child process can request updates by writing to a special file
+ * or by sending a signal to the parent
+ */
+function setupChildIPC() {
+  // Listen for update requests via USR1 signal
+  process.on('SIGUSR1', async () => {
+    console.log('\n📨 Update requested by child process...')
+
+    const info = await checkForUpdates()
+
+    if (!info || !info.updateAvailable) {
+      console.log('✓ No updates available')
+      return
+    }
+
+    console.log('📦 Update available, applying...')
+
+    // Stop child process
+    if (childProcess) {
+      childProcess.kill('SIGTERM')
+      childProcess = null
+    }
+
+    isUpdating = true
+    const success = await performUpdate(info)
+    isUpdating = false
+
+    if (success) {
+      console.log('✓ Update complete! Restarting...')
+      restartRequested = true
+      childProcess = spawnChild()
+    }
+  })
+}
+
+// ============ Main Entry Point ============
+
+async function main() {
+  const args = process.argv.slice(2)
+  const command = args[0]
+
+  // Handle updater-specific commands
+  if (command === 'update') {
+    await cmdUpdate()
+    return
+  }
+
+  if (command === 'update:check' || command === 'check-update') {
+    await cmdUpdateCheck()
+    return
+  }
+
+  if (command === 'version' || command === '--version' || command === '-v') {
+    await cmdVersion()
+    return
+  }
+
+  if (command === 'help' || command === '--help' || command === '-h') {
+    console.log(`
+TalkToCode CLI Updater
+=====================
+
+Commands:
+  ttc <command>    Run command in child process (default)
+  ttc update       Check and apply updates
+  ttc update:check Check for updates without applying
+  ttc version      Show version information
+  ttc help         Show this help message
+
+The updater runs as the main process and spawns the app as a child.
+This allows the updater to update itself even if the app is corrupted.
+`)
+    process.exit(0)
+    return
+  }
+
+  // Default: spawn child process
+  console.log('🎯 TalkToCode CLI Updater')
+  console.log('====================================\n')
+
+  // Silent update check on startup
+  checkForUpdates().then(info => {
+    if (info?.updateAvailable) {
+      console.log('📦 Update available! Run "ttc update" to apply.\n')
+    }
+  }).catch(() => {})
+
+  setupSignalHandlers()
+  setupChildIPC()
+
+  childProcess = spawnChild()
+
+  // Keep updater alive
+  process.on('exit', () => {
+    if (childProcess) {
+      childProcess.kill('SIGTERM')
+    }
+  })
+}
+
+main().catch(error => {
+  console.error('❌ Fatal error:', error)
+  process.exit(1)
+})