@aion0/forge 0.3.0 → 0.3.1

package/components/WebTerminal.tsx

@@ -9,6 +9,7 @@ import '@xterm/xterm/css/xterm.css';
 
 export interface WebTerminalHandle {
   openSessionInTerminal: (sessionId: string, projectPath: string) => void;
+  openProjectTerminal: (projectPath: string, projectName: string) => void;
 }
 
 export interface WebTerminalProps {
@@ -269,21 +270,65 @@ const WebTerminal = forwardRef<WebTerminalHandle, WebTerminalProps>(function Web
 
   useImperativeHandle(ref, () => ({
     openSessionInTerminal(sessionId: string, projectPath: string) {
-      const tree = makeTerminal();
+      const tree = makeTerminal(undefined, projectPath);
       const paneId = firstTerminalId(tree);
-      const cmd = `cd ${projectPath} && claude --resume ${sessionId}\n`;
+      const sf = skipPermissions ? ' --dangerously-skip-permissions' : '';
+      const cmd = `cd "${projectPath}" && claude --resume ${sessionId}${sf}\n`;
       pendingCommands.set(paneId, cmd);
+      const projectName = projectPath.split('/').pop() || 'Terminal';
       const newTab: TabState = {
         id: nextId++,
-        label: `claude ${sessionId.slice(0, 8)}`,
+        label: projectName,
         tree,
         ratios: {},
         activeId: paneId,
+        projectPath,
       };
       setTabs(prev => [...prev, newTab]);
-      setActiveTabId(newTab.id);
+      setTimeout(() => setActiveTabId(newTab.id), 0);
     },
-  }));
+    async openProjectTerminal(projectPath: string, projectName: string) {
+      // Check for existing sessions to use -c
+      let hasSession = false;
+      try {
+        const sRes = await fetch(`/api/claude-sessions/${encodeURIComponent(projectName)}`);
+        const sData = await sRes.json();
+        hasSession = Array.isArray(sData) ? sData.length > 0 : false;
+      } catch {}
+      const sf = skipPermissions ? ' --dangerously-skip-permissions' : '';
+      const resumeFlag = hasSession ? ' -c' : '';
+
+      // Use a ref-stable ID so we can set active after state update
+      let targetTabId: number | null = null;
+
+      setTabs(prev => {
+        // Check if there's already a tab for this project
+        const existing = prev.find(t => t.projectPath === projectPath);
+        if (existing) {
+          targetTabId = existing.id;
+          return prev;
+        }
+        const tree = makeTerminal(undefined, projectPath);
+        const paneId = firstTerminalId(tree);
+        pendingCommands.set(paneId, `cd "${projectPath}" && claude${resumeFlag}${sf}\n`);
+        const newTab: TabState = {
+          id: nextId++,
+          label: projectName,
+          tree,
+          ratios: {},
+          activeId: paneId,
+          projectPath,
+        };
+        targetTabId = newTab.id;
+        return [...prev, newTab];
+      });
+
+      // Set active tab after React processes the state update
+      setTimeout(() => {
+        if (targetTabId !== null) setActiveTabId(targetTabId);
+      }, 0);
+    },
+  }), [skipPermissions]);
 
   // ─── Tab operations ───────────────────────────────────
 

package/instrumentation.ts

@@ -8,8 +8,8 @@ export async function register() {
     // Load ~/.forge/.env.local if it exists (works for both pnpm dev and forge-server)
     const { existsSync, readFileSync } = await import('node:fs');
     const { join } = await import('node:path');
-    const { homedir } = await import('node:os');
-    const dataDir = process.env.FORGE_DATA_DIR || join(homedir(), '.forge');
+    const { getDataDir } = await import('./lib/dirs');
+    const dataDir = getDataDir();
     const envFile = join(dataDir, '.env.local');
     if (existsSync(envFile)) {
       for (const line of readFileSync(envFile, 'utf-8').split('\n')) {

package/lib/claude-sessions.ts

@@ -5,7 +5,7 @@
 
 import { existsSync, readFileSync, statSync, readdirSync, watch, openSync, readSync, closeSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
-import { homedir } from 'node:os';
+import { getClaudeDir } from './dirs';
 import { getProjectInfo } from './projects';
 
 export interface ClaudeSessionInfo {
@@ -33,7 +33,7 @@ export interface SessionEntry {
  */
 export function projectPathToClaudeDir(projectPath: string): string {
   const hash = projectPath.replace(/\//g, '-');
-  return join(homedir(), '.claude', 'projects', hash);
+  return join(getClaudeDir(), 'projects', hash);
 }
 
 /**

package/lib/claude-templates.ts

@@ -0,0 +1,227 @@
+/**
+ * CLAUDE.md template management.
+ *
+ * Templates are reusable markdown snippets that can be appended to project CLAUDE.md files.
+ * Stored in <dataDir>/claude-templates/*.md with frontmatter metadata.
+ * Injection is idempotent — marked with <!-- forge:template:<id> --> comments.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { getDataDir } from './dirs';
+import YAML from 'yaml';
+
+const TEMPLATES_DIR = join(getDataDir(), 'claude-templates');
+
+export interface ClaudeTemplate {
+  id: string;           // filename without .md
+  name: string;
+  description: string;
+  tags: string[];
+  builtin: boolean;
+  isDefault: boolean;   // auto-inject into new projects
+  content: string;      // markdown body (without frontmatter)
+}
+
+function ensureDir() {
+  if (!existsSync(TEMPLATES_DIR)) mkdirSync(TEMPLATES_DIR, { recursive: true });
+}
+
+// ─── Built-in templates ──────────────────────────────────────
+
+const BUILTINS: Record<string, { name: string; description: string; tags: string[]; content: string }> = {
+  'typescript-rules': {
+    name: 'TypeScript Rules',
+    description: 'TypeScript coding conventions and best practices',
+    tags: ['typescript', 'code-style'],
+    content: `## TypeScript Rules
+- Use \`const\` by default, \`let\` only when needed
+- Prefer explicit return types on exported functions
+- Use \`interface\` for object shapes, \`type\` for unions/intersections
+- Avoid \`any\` — use \`unknown\` + type guards
+- Prefer early returns over nested if/else`,
+  },
+  'git-workflow': {
+    name: 'Git Workflow',
+    description: 'Git commit and branch conventions',
+    tags: ['git', 'workflow'],
+    content: `## Git Workflow
+- Commit messages: imperative mood, concise (e.g. "add feature X", "fix bug in Y")
+- Branch naming: \`feature/<name>\`, \`fix/<name>\`, \`chore/<name>\`
+- Always create a new branch for changes, never commit directly to main
+- Run tests before committing`,
+  },
+  'obsidian-vault': {
+    name: 'Obsidian Vault',
+    description: 'Obsidian vault integration for note search and management',
+    tags: ['obsidian', 'docs'],
+    content: `## Obsidian Vault
+When I ask about my notes, use bash to search and read files from the vault directory.
+Example: find <vault_path> -name "*.md" | head -20`,
+  },
+  'security': {
+    name: 'Security Rules',
+    description: 'Security best practices for code generation',
+    tags: ['security'],
+    content: `## Security Rules
+- Never hardcode secrets, API keys, or passwords
+- Validate all user inputs at system boundaries
+- Use parameterized queries for database operations
+- Sanitize outputs to prevent XSS
+- Follow OWASP top 10 guidelines`,
+  },
+};
+
+/** Ensure built-in templates exist on disk */
+export function ensureBuiltins() {
+  ensureDir();
+  for (const [id, tmpl] of Object.entries(BUILTINS)) {
+    const file = join(TEMPLATES_DIR, `${id}.md`);
+    if (!existsSync(file)) {
+      const frontmatter = YAML.stringify({ name: tmpl.name, description: tmpl.description, tags: tmpl.tags, builtin: true });
+      writeFileSync(file, `---\n${frontmatter}---\n\n${tmpl.content}\n`, 'utf-8');
+    }
+  }
+}
+
+// ─── CRUD ────────────────────────────────────────────────────
+
+function parseTemplate(filePath: string): ClaudeTemplate | null {
+  try {
+    const raw = readFileSync(filePath, 'utf-8');
+    const id = basename(filePath, '.md');
+    // Parse frontmatter
+    const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!fmMatch) return { id, name: id, description: '', tags: [], builtin: false, isDefault: false, content: raw.trim() };
+    const meta = YAML.parse(fmMatch[1]) || {};
+    return {
+      id,
+      name: meta.name || id,
+      description: meta.description || '',
+      tags: meta.tags || [],
+      builtin: !!meta.builtin,
+      isDefault: !!meta.isDefault,
+      content: fmMatch[2].trim(),
+    };
+  } catch { return null; }
+}
+
+export function listTemplates(): ClaudeTemplate[] {
+  ensureDir();
+  ensureBuiltins();
+  const files = readdirSync(TEMPLATES_DIR).filter(f => f.endsWith('.md')).sort();
+  return files.map(f => parseTemplate(join(TEMPLATES_DIR, f))).filter(Boolean) as ClaudeTemplate[];
+}
+
+export function getTemplate(id: string): ClaudeTemplate | null {
+  const file = join(TEMPLATES_DIR, `${id}.md`);
+  if (!existsSync(file)) return null;
+  return parseTemplate(file);
+}
+
+export function saveTemplate(id: string, name: string, description: string, tags: string[], content: string, isDefault?: boolean): void {
+  ensureDir();
+  // Preserve builtin flag if editing an existing built-in template
+  const existing = getTemplate(id);
+  const builtin = existing?.builtin || false;
+  const frontmatter = YAML.stringify({ name, description, tags, builtin, isDefault: !!isDefault });
+  writeFileSync(join(TEMPLATES_DIR, `${id}.md`), `---\n${frontmatter}---\n\n${content}\n`, 'utf-8');
+}
+
+/** Toggle default flag on a template */
+export function setTemplateDefault(id: string, isDefault: boolean): boolean {
+  const tmpl = getTemplate(id);
+  if (!tmpl) return false;
+  const file = join(TEMPLATES_DIR, `${id}.md`);
+  const raw = readFileSync(file, 'utf-8');
+  const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!fmMatch) return false;
+  const meta = YAML.parse(fmMatch[1]) || {};
+  meta.isDefault = isDefault;
+  writeFileSync(file, `---\n${YAML.stringify(meta)}---\n${fmMatch[2]}`, 'utf-8');
+  return true;
+}
+
+/** Auto-inject all default templates into a project if not already present */
+export function applyDefaultTemplates(projectPath: string): string[] {
+  const claudeMdPath = join(projectPath, 'CLAUDE.md');
+  const templates = listTemplates();
+  const injected: string[] = [];
+  for (const tmpl of templates) {
+    if (tmpl.isDefault && !isInjected(claudeMdPath, tmpl.id)) {
+      if (injectTemplate(claudeMdPath, tmpl.id)) {
+        injected.push(tmpl.id);
+      }
+    }
+  }
+  return injected;
+}
+
+export function deleteTemplate(id: string): boolean {
+  const tmpl = getTemplate(id);
+  if (!tmpl || tmpl.builtin) return false; // can't delete builtins
+  const file = join(TEMPLATES_DIR, `${id}.md`);
+  try { unlinkSync(file); return true; } catch { return false; }
+}
+
+// ─── Injection ───────────────────────────────────────────────
+
+const MARKER_START = (id: string) => `<!-- forge:template:${id} -->`;
+const MARKER_END = (id: string) => `<!-- /forge:template:${id} -->`;
+
+/** Check if a template is already injected in a CLAUDE.md */
+export function isInjected(claudeMdPath: string, templateId: string): boolean {
+  if (!existsSync(claudeMdPath)) return false;
+  const content = readFileSync(claudeMdPath, 'utf-8');
+  return content.includes(MARKER_START(templateId));
+}
+
+/** Get list of template IDs injected in a CLAUDE.md */
+export function getInjectedTemplates(claudeMdPath: string): string[] {
+  if (!existsSync(claudeMdPath)) return [];
+  const content = readFileSync(claudeMdPath, 'utf-8');
+  const ids: string[] = [];
+  const regex = /<!-- forge:template:(\S+) -->/g;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    ids.push(match[1]);
+  }
+  return ids;
+}
+
+/** Append a template to a CLAUDE.md file. Returns false if already injected. */
+export function injectTemplate(claudeMdPath: string, templateId: string): boolean {
+  const tmpl = getTemplate(templateId);
+  if (!tmpl) return false;
+  if (isInjected(claudeMdPath, templateId)) return false;
+
+  const block = `\n${MARKER_START(templateId)}\n${tmpl.content}\n${MARKER_END(templateId)}\n`;
+
+  if (existsSync(claudeMdPath)) {
+    const existing = readFileSync(claudeMdPath, 'utf-8');
+    writeFileSync(claudeMdPath, existing.trimEnd() + '\n' + block, 'utf-8');
+  } else {
+    // Create new CLAUDE.md
+    const dir = join(claudeMdPath, '..');
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(claudeMdPath, block.trimStart(), 'utf-8');
+  }
+  return true;
+}
+
+/** Remove a template from a CLAUDE.md file */
+export function removeTemplate(claudeMdPath: string, templateId: string): boolean {
+  if (!existsSync(claudeMdPath)) return false;
+  const content = readFileSync(claudeMdPath, 'utf-8');
+  const start = MARKER_START(templateId);
+  const end = MARKER_END(templateId);
+  const startIdx = content.indexOf(start);
+  const endIdx = content.indexOf(end);
+  if (startIdx === -1 || endIdx === -1) return false;
+
+  const before = content.slice(0, startIdx).trimEnd();
+  const after = content.slice(endIdx + end.length).trimStart();
+  const newContent = before + (after ? '\n\n' + after : '') + '\n';
+  writeFileSync(claudeMdPath, newContent, 'utf-8');
+  return true;
+}

package/lib/cloudflared.ts

@@ -5,12 +5,13 @@
 
 import { spawn, execSync, type ChildProcess } from 'node:child_process';
 import { existsSync, mkdirSync, chmodSync, createWriteStream, unlinkSync, writeFileSync, readFileSync } from 'node:fs';
-import { homedir, platform, arch } from 'node:os';
+import { platform, arch } from 'node:os';
 import { join } from 'node:path';
 import https from 'node:https';
 import http from 'node:http';
+import { getConfigDir, getDataDir } from './dirs';
 
-const BIN_DIR = join(homedir(), '.forge', 'bin');
+const BIN_DIR = join(getConfigDir(), 'bin');
 const BIN_NAME = platform() === 'win32' ? 'cloudflared.exe' : 'cloudflared';
 const BIN_PATH = join(BIN_DIR, BIN_NAME);
 
@@ -105,7 +106,7 @@ if (!gAny[stateKey]) {
 const state: TunnelState = gAny[stateKey];
 
 const MAX_LOG_LINES = 100;
-const TUNNEL_STATE_FILE = join(homedir(), '.forge', 'tunnel-state.json');
+const TUNNEL_STATE_FILE = join(getDataDir(), 'tunnel-state.json');
 
 function saveTunnelState() {
   try {

package/lib/crypto.ts

@@ -1,15 +1,14 @@
 /**
  * Encryption utilities for storing secrets in settings.yaml
- * Uses AES-256-GCM with a persistent key stored in ~/.forge/.encrypt-key
+ * Uses AES-256-GCM with a persistent key stored in <dataDir>/.encrypt-key
  */
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
 import { createCipheriv, createDecipheriv, randomBytes, createHash } from 'node:crypto';
+import { getDataDir } from './dirs';
 
-const DATA_DIR = process.env.FORGE_DATA_DIR || join(homedir(), '.forge');
-const KEY_FILE = join(DATA_DIR, '.encrypt-key');
+const KEY_FILE = join(getDataDir(), '.encrypt-key');
 const PREFIX = 'enc:';
 
 function getEncryptionKey(): Buffer {

package/lib/dirs.ts

@@ -0,0 +1,34 @@
+/**
+ * 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';
+
+/** 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');
+}
+
+/** 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/lib/flows.ts

@@ -6,13 +6,13 @@
 
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { homedir } from 'node:os';
 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(homedir(), '.forge', 'flows');
+const FLOWS_DIR = join(getDataDir(), 'flows');
 
 export interface FlowStep {
   project: string;

package/lib/init.ts

@@ -21,9 +21,9 @@ const gInit = globalThis as any;
 function migrateSecrets() {
   try {
     const { existsSync, readFileSync } = require('node:fs');
-    const { homedir } = require('node:os');
     const YAML = require('yaml');
-    const dataDir = process.env.FORGE_DATA_DIR || join(homedir(), '.forge');
+    const { getDataDir: _gdd } = require('./dirs');
+    const dataDir = _gdd();
     const file = join(dataDir, 'settings.yaml');
     if (!existsSync(file)) return;
     const raw = YAML.parse(readFileSync(file, 'utf-8')) || {};

package/lib/password.ts

@@ -11,11 +11,11 @@
  */
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
 import { randomInt } from 'node:crypto';
+import { getDataDir } from './dirs';
 
-const DATA_DIR = process.env.FORGE_DATA_DIR || join(homedir(), '.forge');
+const DATA_DIR = getDataDir();
 const SESSION_CODE_FILE = join(DATA_DIR, 'session-code.json');
 
 /** Generate a random 8-digit numeric code */

package/lib/pipeline.ts

@@ -8,15 +8,15 @@
 import { randomUUID } from 'node:crypto';
 import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { homedir } from 'node:os';
 import YAML from 'yaml';
 import { createTask, getTask, onTaskEvent, taskModelOverrides } from './task-manager';
 import { getProjectInfo } from './projects';
 import { loadSettings } from './settings';
 import type { Task } from '@/src/types';
+import { getDataDir } from './dirs';
 
-const PIPELINES_DIR = join(homedir(), '.forge', 'pipelines');
-const WORKFLOWS_DIR = join(homedir(), '.forge', 'flows');
+const PIPELINES_DIR = join(getDataDir(), 'pipelines');
+const WORKFLOWS_DIR = join(getDataDir(), 'flows');
 
 // Track pipeline task IDs so terminal notifications can skip them (persists across hot-reloads)
 const pipelineTaskKey = Symbol.for('mw-pipeline-task-ids');

package/lib/session-watcher.ts

@@ -8,7 +8,7 @@
 import { randomUUID } from 'node:crypto';
 import { getDb } from '@/src/core/db/database';
 import { join } from 'node:path';
-import { homedir } from 'node:os';
+import { getDataDir } from './dirs';
 import {
   listClaudeSessions,
   getSessionFilePath,
@@ -19,7 +19,7 @@ import {
 import { scanProjects } from './projects';
 import { loadSettings } from './settings';
 
-const DB_PATH = join(homedir(), '.forge', 'data.db');
+const DB_PATH = join(getDataDir(), 'workflow.db');
 
 // ─── Types ───────────────────────────────────────────────────
 

package/lib/settings.ts

@@ -1,16 +1,17 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
 import YAML from 'yaml';
 import { encryptSecret, decryptSecret, isEncrypted, SECRET_FIELDS } from './crypto';
+import { getDataDir } from './dirs';
 
-const DATA_DIR = process.env.FORGE_DATA_DIR || join(homedir(), '.forge');
+const DATA_DIR = getDataDir();
 const SETTINGS_FILE = join(DATA_DIR, 'settings.yaml');
 
 export interface Settings {
   projectRoots: string[];       // Multiple project directories
   docRoots: string[];           // Markdown document directories (e.g. Obsidian vaults)
   claudePath: string;           // Path to claude binary
+  claudeHome: string;           // Claude Code home directory (default: ~/.claude)
   telegramBotToken: string;     // Telegram Bot API token
   telegramChatId: string;       // Telegram chat ID to send notifications to
   notifyOnComplete: boolean;    // Notify when task completes
@@ -31,6 +32,7 @@ const defaults: Settings = {
   projectRoots: [],
   docRoots: [],
   claudePath: '',
+  claudeHome: '',
   telegramBotToken: '',
   telegramChatId: '',
   notifyOnComplete: true,