loopwork 0.3.0 → 0.3.1

package/package.json

@@ -1,16 +1,40 @@
 {
   "name": "loopwork",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Loopwork - AI task runner with pluggable backends",
   "main": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./contracts": "./src/contracts/index.ts"
+  },
   "bin": {
     "loopwork": "bin/loopwork"
   },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "CHANGELOG.md",
+    "SECURITY.md",
+    ".env.example",
+    "examples/"
+  ],
   "scripts": {
     "start": "bun run src/index.ts",
-    "build": "bun build ./src/index.ts --compile --outfile bin/loopwork",
+    "build": "bun build ./src/index.ts --compile --outfile bin/loopwork && bun build ./src/index.ts --outdir dist --target node --external bun",
     "test": "bun test",
-    "setup-labels": "bun run src/setup-labels.ts"
+    "setup-labels": "bun run src/setup-labels.ts",
+    "posts:generate": "bun run scripts/generate-posts.ts",
+    "posts:schedule": "bun run scripts/schedule-linkedin-posts.ts",
+    "posts:preview": "bun run scripts/generate-posts.ts markdown",
+    "prepack": "npm run build",
+    "pack:dry": "npm pack --dry-run",
+    "pack:check": "npm pack && tar -tzf *.tgz && rm *.tgz",
+    "prepublishOnly": "npm run build && npm run test",
+    "security:audit": "npm audit --audit-level=moderate",
+    "security:check": "npm outdated && npm audit",
+    "security:fix": "npm audit fix",
+    "security:trivy": "trivy fs . --severity CRITICAL,HIGH,MEDIUM || echo 'Trivy not installed. Run: brew install aquasecurity/trivy/trivy'"
   },
   "dependencies": {
     "chalk": "^5.3.0",
@@ -22,5 +46,25 @@
     "@types/bun": "latest",
     "@types/node": "^20.0.0",
     "@types/react": "^18.2.0"
-  }
+  },
+  "keywords": [
+    "ai",
+    "automation",
+    "task-runner",
+    "github",
+    "workflow",
+    "cli",
+    "loopwork",
+    "agent"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nadimtuhin/loopwork.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nadimtuhin/loopwork/issues"
+  },
+  "homepage": "https://github.com/nadimtuhin/loopwork#readme",
+  "author": "Nadim Tuhin",
+  "license": "MIT"
 }

package/src/backends/github.ts

@@ -11,7 +11,7 @@ const DEPENDS_PATTERN = /(?:^|\n)\s*(?:Depends on|depends on|Dependencies|depend
 interface GitHubIssue {
   number: number
   title: string
-  body: string
+  body?: string
   state: 'open' | 'closed'
   labels: { name: string }[]
   url: string
@@ -75,7 +75,10 @@ export class GitHubTaskAdapter implements TaskBackend {
 
   async findNextTask(options?: FindTaskOptions): Promise<Task | null> {
     const tasks = await this.listPendingTasks(options)
-    return tasks[0] || null
+    const task = tasks[0] || null
+    if (!task) return null
+
+    return this.getTask(task.id)
   }
 
   async getTask(taskId: string): Promise<Task | null> {
@@ -101,7 +104,7 @@ export class GitHubTaskAdapter implements TaskBackend {
     try {
       return await this.withRetry(async () => {
         const labelArg = labels.join(',')
-        const result = await $`gh issue list ${this.repoFlag()} --label "${labelArg}" --state open --json number,title,body,labels,url --limit 100`.quiet()
+        const result = await $`gh issue list ${this.repoFlag()} --label "${labelArg}" --state open --json number,title,labels,url --limit 100`.quiet()
         const issues: GitHubIssue[] = JSON.parse(result.stdout.toString())
         return issues.map(issue => this.adaptIssue(issue))
       })

package/src/backends/json.ts

@@ -143,11 +143,12 @@ export class JsonTaskAdapter implements TaskBackend {
     if (options?.startFrom) {
       const startIdx = tasks.findIndex(t => t.id === options.startFrom)
       if (startIdx >= 0) {
-        return tasks[startIdx]
+        return this.getTask(tasks[startIdx].id)
       }
     }
 
-    return tasks[0] || null
+    if (!tasks[0]) return null
+    return this.getTask(tasks[0].id)
   }
 
   async getTask(taskId: string): Promise<Task | null> {
@@ -194,20 +195,37 @@ export class JsonTaskAdapter implements TaskBackend {
 
     const tasks: Task[] = []
     for (const entry of entries) {
-      const task = await this.loadFullTask(entry, data)
-      if (task) {
-        // Check if task dependencies are met
-        if (!options?.includeBlocked && task.dependsOn && task.dependsOn.length > 0) {
-          const depsMet = await this.areDependenciesMetInternal(task.dependsOn, data)
-          if (!depsMet) continue // Skip blocked tasks
-        }
-        tasks.push(task)
+      // Check if task dependencies are met
+      if (!options?.includeBlocked && entry.dependsOn && entry.dependsOn.length > 0) {
+        const depsMet = await this.areDependenciesMetInternal(entry.dependsOn, data)
+        if (!depsMet) continue // Skip blocked tasks
       }
+
+      const task = this.loadTaskSummary(entry, data)
+      tasks.push(task)
     }
 
     return tasks
   }
 
+  private loadTaskSummary(entry: JsonTaskEntry, data: JsonTasksFile): Task {
+    const featureInfo = entry.feature && data.features?.[entry.feature]
+
+    return {
+      id: entry.id,
+      title: entry.id,
+      description: '',
+      status: entry.status,
+      priority: entry.priority || 'medium',
+      feature: entry.feature,
+      parentId: entry.parentId,
+      dependsOn: entry.dependsOn,
+      metadata: {
+        featureName: featureInfo?.name,
+      },
+    }
+  }
+
   /**
    * Internal method to check if dependencies are met
    */

package/src/commands/run.ts

@@ -6,8 +6,8 @@ import { createBackend, type TaskBackend, type Task } from '../backends'
 import { CliExecutor } from '../core/cli'
 import { logger } from '../core/utils'
 import { plugins } from '../plugins'
-import { createCostTrackingPlugin } from '../plugins/cost-tracking'
-import { createTelegramHookPlugin } from '../plugins/telegram/notifications'
+import { createCostTrackingPlugin } from '../../../cost-tracking/src/index'
+import { createTelegramHookPlugin } from '../../../telegram/src/notifications'
 import type { TaskContext } from '../contracts/plugin'
 
 function generateSuccessCriteria(task: Task): string[] {

package/src/contracts/config.ts

@@ -5,72 +5,6 @@
 import type { LoopworkPlugin } from './plugin'
 import type { BackendConfig } from './backend'
 
-/**
- * Telegram plugin configuration
- */
-export interface TelegramConfig {
-  botToken?: string
-  chatId?: string
-  notifications?: boolean
-  silent?: boolean
-}
-
-/**
- * Discord plugin configuration
- */
-export interface DiscordConfig {
-  webhookUrl?: string
-  username?: string
-  avatarUrl?: string
-  notifyOnStart?: boolean
-  notifyOnComplete?: boolean
-  notifyOnFail?: boolean
-  notifyOnLoopEnd?: boolean
-  mentionOnFail?: string
-}
-
-/**
- * Asana plugin configuration
- */
-export interface AsanaConfig {
-  accessToken?: string
-  projectId?: string
-  workspaceId?: string
-  autoCreate?: boolean
-  syncStatus?: boolean
-}
-
-/**
- * Everhour plugin configuration
- */
-export interface EverhourConfig {
-  apiKey?: string
-  autoStartTimer?: boolean
-  autoStopTimer?: boolean
-  projectId?: string
-  dailyLimit?: number
-}
-
-/**
- * Todoist plugin configuration
- */
-export interface TodoistConfig {
-  apiToken?: string
-  projectId?: string
-  syncStatus?: boolean
-  addComments?: boolean
-}
-
-/**
- * Cost tracking configuration
- */
-export interface CostTrackingConfig {
-  enabled?: boolean
-  defaultModel?: string
-  dailyBudget?: number
-  alertThreshold?: number
-}
-
 /**
  * Main Loopwork configuration
  */
@@ -99,23 +33,17 @@ export interface LoopworkConfig {
   taskDelay?: number
   retryDelay?: number
 
-  // Plugin configs
-  telegram?: TelegramConfig
-  discord?: DiscordConfig
-  asana?: AsanaConfig
-  everhour?: EverhourConfig
-  todoist?: TodoistConfig
-  costTracking?: CostTrackingConfig
-
   // Registered plugins
   plugins?: LoopworkPlugin[]
+
+  [key: string]: any
 }
 
 /**
  * Default configuration values
  */
 export const DEFAULT_CONFIG: Partial<LoopworkConfig> = {
-  cli: 'opencode',
+  cli: 'claude',
   maxIterations: 50,
   timeout: 600,
   namespace: 'default',

package/src/contracts/index.ts

@@ -33,11 +33,5 @@ export type {
 // Config types
 export type {
   LoopworkConfig,
-  TelegramConfig,
-  DiscordConfig,
-  AsanaConfig,
-  EverhourConfig,
-  TodoistConfig,
-  CostTrackingConfig,
 } from './config'
 export { DEFAULT_CONFIG } from './config'

package/src/core/cli.ts

@@ -1,25 +1,26 @@
 import { spawn, spawnSync, ChildProcess } from 'child_process'
 import fs from 'fs'
 import path from 'path'
-import { logger } from './utils'
+import { logger, StreamLogger } from './utils'
 import type { Config } from './config'
 
 export interface CliConfig {
   name: string
+  displayName?: string
   cli: 'opencode' | 'claude'
   model: string
 }
 
 // Default model pools
 export const EXEC_MODELS: CliConfig[] = [
-  { name: 'sonnet-claude', cli: 'claude', model: 'sonnet' },
-  { name: 'sonnet-opencode', cli: 'opencode', model: 'google/antigravity-claude-sonnet-4-5' },
-  { name: 'gemini-3-flash', cli: 'opencode', model: 'google/antigravity-gemini-3-flash' },
+  { name: 'sonnet-claude', displayName: 'claude', cli: 'claude', model: 'sonnet' },
+  { name: 'sonnet-opencode', displayName: 'sonnet', cli: 'opencode', model: 'google/antigravity-claude-sonnet-4-5' },
+  { name: 'gemini-3-flash', displayName: 'gemini-flash', cli: 'opencode', model: 'google/antigravity-gemini-3-flash' },
 ]
 
 export const FALLBACK_MODELS: CliConfig[] = [
-  { name: 'opus-claude', cli: 'claude', model: 'opus' },
-  { name: 'gemini-3-pro', cli: 'opencode', model: 'google/antigravity-gemini-3-pro' },
+  { name: 'opus-claude', displayName: 'opus', cli: 'claude', model: 'opus' },
+  { name: 'gemini-3-pro', displayName: 'gemini-pro', cli: 'opencode', model: 'google/antigravity-gemini-3-pro' },
 ]
 
 export class CliExecutor {
@@ -110,6 +111,7 @@ export class CliExecutor {
 
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
       const cliConfig = this.getNextCliConfig()
+      const displayName = cliConfig.displayName || cliConfig.name
       const cliPath = this.cliPaths.get(cliConfig.cli)
 
       if (!cliPath) {
@@ -132,9 +134,9 @@ export class CliExecutor {
         ? `opencode run --model ${cliConfig.model} "<prompt>"`
         : `claude -p --dangerously-skip-permissions --model ${cliConfig.model}`
 
-      logger.info(`[${cliConfig.name}] Executing: ${cmdDisplay}`)
-      logger.info(`[${cliConfig.name}] Timeout: ${timeoutSecs}s`)
-      logger.info(`[${cliConfig.name}] Log file: ${outputFile}`)
+      logger.info(`[${displayName}] Executing: ${cmdDisplay}`)
+      logger.info(`[${displayName}] Timeout: ${timeoutSecs}s`)
+      logger.info(`[${displayName}] Log file: ${outputFile}`)
       logger.info('─────────────────────────────────────')
       logger.info('📝 Streaming CLI output below...')
       logger.info('─────────────────────────────────────')
@@ -142,13 +144,17 @@ export class CliExecutor {
       const result = await this.spawnWithTimeout(
         cliPath,
         args,
-        { env, input: cliConfig.cli === 'claude' ? prompt : undefined },
+        {
+          env,
+          input: cliConfig.cli === 'claude' ? prompt : undefined,
+          prefix: displayName,
+        },
         outputFile,
         timeoutSecs
       )
 
       if (result.timedOut) {
-        logger.error(`Timed out with ${cliConfig.name}`)
+        logger.error(`Timed out with ${displayName}`)
         continue
       }
 
@@ -158,13 +164,13 @@ export class CliExecutor {
         : ''
 
       if (/rate.*limit|too.*many.*request|429|RESOURCE_EXHAUSTED/i.test(output)) {
-        logger.warn(`Rate limited on ${cliConfig.name}, waiting 30s...`)
+        logger.warn(`Rate limited on ${displayName}, waiting 30s...`)
         await new Promise(r => setTimeout(r, 30000))
         continue
       }
 
       if (/quota.*exceed|billing.*limit/i.test(output)) {
-        logger.warn(`Quota exhausted for ${cliConfig.name}`)
+        logger.warn(`Quota exhausted for ${displayName}`)
         this.switchToFallback()
         continue
       }
@@ -186,7 +192,7 @@ export class CliExecutor {
   private spawnWithTimeout(
     command: string,
     args: string[],
-    options: { env?: NodeJS.ProcessEnv; input?: string },
+    options: { env?: NodeJS.ProcessEnv; input?: string; prefix?: string },
     outputFile: string,
     timeoutSecs: number
   ): Promise<{ exitCode: number; timedOut: boolean }> {
@@ -194,6 +200,7 @@ export class CliExecutor {
       const writeStream = fs.createWriteStream(outputFile)
       let timedOut = false
       const startTime = Date.now()
+      const streamLogger = new StreamLogger(options.prefix)
 
       const child = spawn(command, args, {
         env: options.env,
@@ -212,12 +219,12 @@ export class CliExecutor {
 
       child.stdout?.on('data', (data) => {
         writeStream.write(data)
-        process.stdout.write(data)
+        streamLogger.log(data)
       })
 
       child.stderr?.on('data', (data) => {
         writeStream.write(data)
-        process.stderr.write(data)
+        streamLogger.log(data)
       })
 
       if (child.stdin) {
@@ -236,6 +243,7 @@ export class CliExecutor {
       child.on('close', (code) => {
         clearInterval(progressInterval)
         clearTimeout(timer)
+        streamLogger.flush()
         writeStream.end()
         this.currentSubprocess = null
         const totalTime = Math.floor((Date.now() - startTime) / 1000)
@@ -265,6 +273,7 @@ export class CliExecutor {
       child.on('error', (err) => {
         clearInterval(progressInterval)
         clearTimeout(timer)
+        streamLogger.flush()
         writeStream.end()
         this.currentSubprocess = null
         logger.error(`Spawn error: ${err.message}`)

package/src/core/state.ts

@@ -144,10 +144,16 @@ export class StateManager {
    * Clear saved state
    */
   clearState(): void {
-    if (fs.existsSync(this.stateFile)) {
-      fs.unlinkSync(this.stateFile)
-      if (this.config.debug) {
-        console.log('State cleared')
+    try {
+      if (fs.existsSync(this.stateFile)) {
+        fs.unlinkSync(this.stateFile)
+        if (this.config.debug) {
+          console.log('State cleared')
+        }
+      }
+    } catch (e: any) {
+      if (e.code !== 'ENOENT') {
+        console.error('Failed to clear state')
       }
     }
   }

package/src/core/utils.ts

@@ -98,13 +98,15 @@ export async function promptUser(
 
 export class StreamLogger {
   private buffer: string = ''
+  private prefix: string = ''
+
+  constructor(prefix?: string) {
+    this.prefix = prefix || ''
+  }
 
   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) {
@@ -113,7 +115,11 @@ export class StreamLogger {
   }
 
   private printLine(line: string) {
-    process.stdout.write(`${chalk.gray(getTimestamp())} ${line}\n`)
+    process.stdout.write('\r\x1b[K')
+    const timestamp = chalk.gray(getTimestamp())
+    const separator = chalk.gray(' │')
+    const prefixStr = this.prefix ? ` ${chalk.magenta(`[${this.prefix}]`)}` : ''
+    process.stdout.write(`${timestamp}${separator}${prefixStr} ${chalk.dim(line)}\n`)
   }
 
   flush() {

package/src/monitor/index.ts

@@ -59,13 +59,19 @@ export class LoopworkMonitor {
     // Spawn background process
     const logStream = fs.openSync(logFile, 'a')
 
+    // Find the real package root - either we are in it, or it's in packages/loopwork
+    const currentPkgDir = path.join(this.projectRoot, 'packages/loopwork')
+    const spawnCwd = fs.existsSync(currentPkgDir) ? currentPkgDir : this.projectRoot
+
     const child: ChildProcess = spawn('bun', ['run', 'src/index.ts', ...fullArgs], {
-      cwd: path.join(this.projectRoot, 'packages/loopwork'),
+      cwd: spawnCwd,
       detached: true,
       stdio: ['ignore', logStream, logStream],
     })
 
-    child.unref()
+    if (child.unref) {
+      child.unref()
+    }
 
     if (!child.pid) {
       return { success: false, error: 'Failed to spawn process' }
@@ -174,32 +180,36 @@ export class LoopworkMonitor {
     const namespaces: { name: string; status: 'running' | 'stopped'; lastRun?: string }[] = []
 
     if (fs.existsSync(runsDir)) {
-      const dirs = fs.readdirSync(runsDir, { withFileTypes: true })
-        .filter(d => d.isDirectory())
-        .map(d => d.name)
-
-      for (const name of dirs) {
-        const isRunning = running.some(p => p.namespace === name)
-        const nsDir = path.join(runsDir, name)
-
-        // Find last run timestamp
-        let lastRun: string | undefined
-        const runDirs = fs.readdirSync(nsDir, { withFileTypes: true })
-          .filter(d => d.isDirectory() && d.name !== 'monitor-logs')
+      try {
+        const dirs = fs.readdirSync(runsDir, { withFileTypes: true })
+          .filter(d => d.isDirectory())
           .map(d => d.name)
-          .sort()
-          .reverse()
 
-        if (runDirs.length > 0) {
-          lastRun = runDirs[0]
+        for (const name of dirs) {
+          const isRunning = running.some(p => p.namespace === name)
+          const nsDir = path.join(runsDir, name)
+
+          // Find last run timestamp
+          let lastRun: string | undefined
+          try {
+            const runDirs = fs.readdirSync(nsDir, { withFileTypes: true })
+              .filter(d => d.isDirectory() && d.name !== 'monitor-logs')
+              .map(d => d.name)
+              .sort()
+              .reverse()
+
+            if (runDirs.length > 0) {
+              lastRun = runDirs[0]
+            }
+          } catch (e) {}
+
+          namespaces.push({
+            name,
+            status: isRunning ? 'running' : 'stopped',
+            lastRun,
+          })
         }
-
-        namespaces.push({
-          name,
-          status: isRunning ? 'running' : 'stopped',
-          lastRun,
-        })
-      }
+      } catch (e) {}
     }
 
     return { running, namespaces }
@@ -220,13 +230,15 @@ export class LoopworkMonitor {
       // Find most recent log file
       const logsDir = path.join(this.projectRoot, 'loopwork-runs', namespace, 'monitor-logs')
       if (fs.existsSync(logsDir)) {
-        const files = fs.readdirSync(logsDir)
-          .filter(f => f.endsWith('.log'))
-          .sort()
-          .reverse()
-        if (files.length > 0) {
-          logFile = path.join(logsDir, files[0])
-        }
+        try {
+          const files = fs.readdirSync(logsDir)
+            .filter(f => f.endsWith('.log'))
+            .sort()
+            .reverse()
+          if (files.length > 0) {
+            logFile = path.join(logsDir, files[0])
+          }
+        } catch (e) {}
       }
     }
 
@@ -255,14 +267,24 @@ export class LoopworkMonitor {
     try {
       if (fs.existsSync(this.stateFile)) {
         const content = fs.readFileSync(this.stateFile, 'utf-8')
+        if (!content || content.trim() === 'undefined') {
+          return { processes: [] }
+        }
         return JSON.parse(content)
       }
-    } catch {}
+    } catch (e) {
+      console.error(`Failed to load monitor state: ${e}`)
+    }
     return { processes: [] }
   }
 
   private saveState(state: MonitorState): void {
-    fs.writeFileSync(this.stateFile, JSON.stringify(state, null, 2))
+    try {
+      if (!state) state = { processes: [] }
+      fs.writeFileSync(this.stateFile, JSON.stringify(state, null, 2))
+    } catch (e) {
+      console.error(`Failed to save monitor state: ${e}`)
+    }
   }
 }