loopwork 0.3.0

package/src/core/state.ts

@@ -0,0 +1,154 @@
+import fs from 'fs'
+import path from 'path'
+import type { Config } from './config'
+
+/**
+ * State Manager for loopwork
+ *
+ * Note: Primary state (task status) lives in GitHub Issues.
+ * This manages local session state and locking only.
+ */
+export class StateManager {
+  private stateFile: string
+  private lockFile: string
+  private namespace: string
+
+  constructor(private config: Config) {
+    this.namespace = config.namespace || 'default'
+    // Use namespace in file paths to allow concurrent loops
+    const suffix = this.namespace === 'default' ? '' : `-${this.namespace}`
+    this.stateFile = path.join(config.projectRoot, `.loopwork-state${suffix}`)
+    this.lockFile = path.join(config.projectRoot, `.loopwork${suffix}.lock`)
+  }
+
+  getNamespace(): string {
+    return this.namespace
+  }
+
+  getLockFile(): string {
+    return this.lockFile
+  }
+
+  getStateFile(): string {
+    return this.stateFile
+  }
+
+  /**
+   * Acquire exclusive lock to prevent multiple instances
+   */
+  acquireLock(retryCount = 0): boolean {
+    if (retryCount > 3) {
+      console.error('Failed to acquire lock after multiple attempts')
+      return false
+    }
+
+    try {
+      fs.mkdirSync(this.lockFile)
+      fs.writeFileSync(path.join(this.lockFile, 'pid'), process.pid.toString())
+      return true
+    } catch (error) {
+      // Check if lock is stale
+      try {
+        const pidFile = path.join(this.lockFile, 'pid')
+        if (fs.existsSync(pidFile)) {
+          const pid = fs.readFileSync(pidFile, 'utf-8')
+          try {
+            process.kill(parseInt(pid, 10), 0)
+            console.error(`Another loopwork is running (PID: ${pid})`)
+            return false
+          } catch (e) {
+            console.warn(`Stale lock found (process ${pid} not running), removing...`)
+            fs.rmSync(this.lockFile, { recursive: true, force: true })
+            return this.acquireLock(retryCount + 1)
+          }
+        }
+      } catch (e) {
+        console.error('Failed to acquire lock (unknown reason)')
+        return false
+      }
+    }
+    return false
+  }
+
+  /**
+   * Release the lock
+   */
+  releaseLock(): void {
+    try {
+      if (fs.existsSync(this.lockFile)) {
+        fs.rmSync(this.lockFile, { recursive: true, force: true })
+      }
+    } catch (e) {
+      console.error('Failed to release lock')
+    }
+  }
+
+  /**
+   * Save current session state
+   */
+  saveState(currentIssue: number, iteration: number): void {
+    const content = [
+      `NAMESPACE=${this.namespace}`,
+      `LAST_ISSUE=${currentIssue}`,
+      `LAST_ITERATION=${iteration}`,
+      `LAST_OUTPUT_DIR=${this.config.outputDir}`,
+      `SESSION_ID=${this.config.sessionId}`,
+      `SAVED_AT=${new Date().toISOString()}`,
+    ].join('\n')
+
+    try {
+      fs.writeFileSync(this.stateFile, content, { mode: 0o600 })
+      if (this.config.debug) {
+        console.log(`State saved: issue=#${currentIssue}, iteration=${iteration}`)
+      }
+    } catch (e) {
+      console.error('Failed to save state')
+    }
+  }
+
+  /**
+   * Load previous session state
+   */
+  loadState(): { lastIssue: number; lastIteration: number; lastOutputDir: string } | null {
+    if (!fs.existsSync(this.stateFile)) {
+      return null
+    }
+
+    try {
+      const content = fs.readFileSync(this.stateFile, 'utf-8')
+      const state: Record<string, string> = {}
+
+      content.split('\n').forEach((line) => {
+        const idx = line.indexOf('=')
+        if (idx !== -1) {
+          const key = line.substring(0, idx)
+          const value = line.substring(idx + 1)
+          if (key && value) state[key] = value
+        }
+      })
+
+      if (!state.LAST_ISSUE) return null
+
+      return {
+        lastIssue: parseInt(state.LAST_ISSUE, 10),
+        lastIteration: parseInt(state.LAST_ITERATION || '0', 10),
+        lastOutputDir: state.LAST_OUTPUT_DIR || '',
+      }
+    } catch (e) {
+      console.error('Failed to load state')
+      return null
+    }
+  }
+
+  /**
+   * Clear saved state
+   */
+  clearState(): void {
+    if (fs.existsSync(this.stateFile)) {
+      fs.unlinkSync(this.stateFile)
+      if (this.config.debug) {
+        console.log('State cleared')
+      }
+    }
+  }
+}

package/src/core/utils.ts

@@ -0,0 +1,125 @@
+import chalk from 'chalk'
+
+export function getTimestamp(): string {
+  return new Date().toLocaleTimeString('en-US', {
+    hour: 'numeric',
+    minute: '2-digit',
+    second: '2-digit',
+    hour12: true,
+  })
+}
+
+export const logger = {
+  info: (msg: string) => {
+    process.stdout.write('\r\x1b[K')
+    console.log(chalk.gray(getTimestamp()), chalk.blue('[INFO]'), msg)
+  },
+  success: (msg: string) => {
+    process.stdout.write('\r\x1b[K')
+    console.log(chalk.gray(getTimestamp()), chalk.green('[SUCCESS]'), msg)
+  },
+  warn: (msg: string) => {
+    process.stdout.write('\r\x1b[K')
+    console.log(chalk.gray(getTimestamp()), chalk.yellow('[WARN]'), msg)
+  },
+  error: (msg: string) => {
+    process.stdout.write('\r\x1b[K')
+    console.log(chalk.gray(getTimestamp()), chalk.red('[ERROR]'), msg)
+  },
+  debug: (msg: string) => {
+    if (process.env.LOOPWORK_DEBUG === 'true') {
+      process.stdout.write('\r\x1b[K')
+      console.log(chalk.gray(getTimestamp()), chalk.cyan('[DEBUG]'), msg)
+    }
+  },
+  update: (msg: string) => {
+    process.stdout.write(
+      `\r\x1b[K${chalk.gray(getTimestamp())} ${chalk.blue('[INFO]')} ${msg}`
+    )
+  },
+}
+
+export async function promptUser(
+  question: string,
+  defaultValue: string = 'n',
+  nonInteractive: boolean = false
+): Promise<string> {
+  if (nonInteractive || !process.stdin.isTTY) {
+    logger.debug(`Non-interactive mode, using default: ${defaultValue}`)
+    return defaultValue
+  }
+
+  process.stdout.write(question)
+  process.stdin.setRawMode(true)
+
+  return new Promise<string>((resolve) => {
+    process.stdin.resume()
+
+    const cleanup = () => {
+      try {
+        process.stdin.setRawMode(false)
+      } catch {
+        // stdin may already be closed
+      }
+      process.stdin.pause()
+      process.stdin.removeListener('data', onData)
+      process.stdin.removeListener('error', onError)
+    }
+
+    const onData = (data: Buffer) => {
+      const char = data.toString('utf8')
+
+      // Handle Ctrl+C
+      if (char === '\u0003') {
+        cleanup()
+        process.stdout.write('\n')
+        logger.info('Interrupted by user (Ctrl+C)')
+        process.exit(130)
+      }
+
+      cleanup()
+      process.stdout.write('\n')
+      if (char === '\r' || char === '\n') {
+        resolve(defaultValue)
+      } else {
+        resolve(char.trim())
+      }
+    }
+
+    const onError = (err: Error) => {
+      cleanup()
+      logger.debug(`stdin error: ${err.message}`)
+      resolve(defaultValue)
+    }
+
+    process.stdin.once('error', onError)
+  })
+}
+
+export class StreamLogger {
+  private buffer: string = ''
+
+  log(chunk: string | Buffer) {
+    this.buffer += chunk.toString('utf8')
+    const lines = this.buffer.split('\n')
+
+    // The last element is either an empty string (if buffer ended with \n)
+    // or a partial line. Keep it in the buffer.
+    this.buffer = lines.pop() || ''
+
+    for (const line of lines) {
+      this.printLine(line)
+    }
+  }
+
+  private printLine(line: string) {
+    process.stdout.write(`${chalk.gray(getTimestamp())} ${line}\n`)
+  }
+
+  flush() {
+    if (this.buffer) {
+      this.printLine(this.buffer)
+      this.buffer = ''
+    }
+  }
+}