@aion0/forge 0.5.26 → 0.5.27

package/.forge/worktrees/pipeline-4dd8dc2d/lib/dirs.ts

@@ -0,0 +1,99 @@
+/**
+ * Centralized directory paths for Forge.
+ *
+ * Shared (configDir):  ~/.forge/          — only bin/ (cloudflared)
+ * Instance (dataDir):  ~/.forge/data/     — settings, db, state, flows, etc.
+ *                      or --dir / FORGE_DATA_DIR
+ * Claude (claudeDir):  ~/.claude/         — or configured in settings
+ */
+
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { existsSync, mkdirSync, renameSync, copyFileSync } from 'node:fs';
+
+/** Shared config directory — only binaries, fixed at ~/.forge/ */
+export function getConfigDir(): string {
+  return join(homedir(), '.forge');
+}
+
+/** Instance data directory — all instance-specific data */
+export function getDataDir(): string {
+  return process.env.FORGE_DATA_DIR || join(getConfigDir(), 'data');
+}
+
+// ─── Migration from old layout (~/.forge/*) to new (~/.forge/data/*) ───
+
+const MIGRATE_FILES = [
+  'settings.yaml',
+  '.encrypt-key',
+  '.env.local',
+  'session-code.json',
+  'terminal-state.json',
+  'tunnel-state.json',
+  'preview.json',
+  'forge.pid',
+  'forge.log',
+];
+const MIGRATE_DIRS = ['flows', 'pipelines'];
+
+let migrated = false;
+
+/** Migrate old ~/.forge/ flat layout to ~/.forge/data/ if needed */
+export function migrateDataDir(): void {
+  if (migrated) return;
+  migrated = true;
+
+  // Only migrate default data dir, not custom --dir
+  if (process.env.FORGE_DATA_DIR) return;
+
+  const configDir = getConfigDir();
+  const dataDir = join(configDir, 'data');
+
+  // Check if old layout exists (settings.yaml in root, not in data/)
+  const oldSettings = join(configDir, 'settings.yaml');
+  const newSettings = join(dataDir, 'settings.yaml');
+  if (!existsSync(oldSettings) || existsSync(newSettings)) return;
+
+  console.log('[forge] Migrating data from ~/.forge/ to ~/.forge/data/...');
+  if (!existsSync(dataDir)) mkdirSync(dataDir, { recursive: true });
+
+  // Migrate files
+  for (const file of MIGRATE_FILES) {
+    const src = join(configDir, file);
+    const dest = join(dataDir, file);
+    if (existsSync(src) && !existsSync(dest)) {
+      try { copyFileSync(src, dest); console.log(`  ${file}`); } catch {}
+    }
+  }
+
+  // Migrate old data.db → data/workflow.db
+  const oldDb = join(configDir, 'data.db');
+  const newDb = join(dataDir, 'workflow.db');
+  if (existsSync(oldDb) && !existsSync(newDb)) {
+    try { copyFileSync(oldDb, newDb); console.log('  data.db → workflow.db'); } catch {}
+  }
+
+  // Migrate directories
+  for (const dir of MIGRATE_DIRS) {
+    const src = join(configDir, dir);
+    const dest = join(dataDir, dir);
+    if (existsSync(src) && !existsSync(dest)) {
+      try { renameSync(src, dest); console.log(`  ${dir}/`); } catch {}
+    }
+  }
+
+  console.log('[forge] Migration complete. Old files kept as backup.');
+}
+
+/** Claude Code home directory — skills, commands, sessions */
+export function getClaudeDir(): string {
+  // Env var takes precedence
+  if (process.env.CLAUDE_HOME) return process.env.CLAUDE_HOME;
+  // Try to read from settings (lazy require to avoid circular dependency)
+  try {
+    const { loadSettings } = require('./settings');
+    const settings = loadSettings();
+    if (settings.claudeHome) return settings.claudeHome.replace(/^~/, homedir());
+  } catch {}
+  return join(homedir(), '.claude');
+}

package/.forge/worktrees/pipeline-4dd8dc2d/lib/flows.ts

@@ -0,0 +1,86 @@
+/**
+ * Workflow (Flow) engine — loads YAML flow definitions and executes them.
+ *
+ * Flow files live in ~/.forge/flows/*.yaml
+ */
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import YAML from 'yaml';
+import { createTask } from './task-manager';
+import { getProjectInfo } from './projects';
+import type { Task } from '@/src/types';
+import { getDataDir } from './dirs';
+
+const FLOWS_DIR = join(getDataDir(), 'flows');
+
+export interface FlowStep {
+  project: string;
+  prompt: string;
+  priority?: number;
+  dependsOn?: string;  // step name to wait for
+}
+
+export interface Flow {
+  name: string;
+  description?: string;
+  schedule?: string;    // cron expression for auto-trigger
+  steps: FlowStep[];
+}
+
+export function listFlows(): Flow[] {
+  if (!existsSync(FLOWS_DIR)) return [];
+
+  return readdirSync(FLOWS_DIR)
+    .filter(f => f.endsWith('.yaml') || f.endsWith('.yml'))
+    .map(f => {
+      try {
+        const raw = readFileSync(join(FLOWS_DIR, f), 'utf-8');
+        const parsed = YAML.parse(raw);
+        return {
+          name: parsed.name || f.replace(/\.ya?ml$/, ''),
+          description: parsed.description,
+          schedule: parsed.schedule,
+          steps: parsed.steps || [],
+        } as Flow;
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean) as Flow[];
+}
+
+export function getFlow(name: string): Flow | null {
+  return listFlows().find(f => f.name === name) || null;
+}
+
+/**
+ * Run a flow — creates tasks for each step.
+ * Steps without dependsOn run immediately (queued).
+ * Steps with dependsOn will be handled by a follow-up mechanism.
+ */
+export function runFlow(name: string): { flow: Flow; tasks: Task[] } {
+  const flow = getFlow(name);
+  if (!flow) throw new Error(`Flow not found: ${name}`);
+
+  const tasks: Task[] = [];
+
+  for (const step of flow.steps) {
+    const project = getProjectInfo(step.project);
+    if (!project) {
+      console.error(`[flow] Project not found: ${step.project}, skipping step`);
+      continue;
+    }
+
+    const task = createTask({
+      projectName: project.name,
+      projectPath: project.path,
+      prompt: step.prompt,
+      priority: step.priority || 0,
+    });
+
+    tasks.push(task);
+  }
+
+  return { flow, tasks };
+}