@aion0/forge 0.1.10 → 0.2.1

package/lib/settings.ts

@@ -7,6 +7,7 @@ const SETTINGS_FILE = join(homedir(), '.forge', '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
   telegramBotToken: string;     // Telegram Bot API token
   telegramChatId: string;       // Telegram chat ID to send notifications to
@@ -18,6 +19,7 @@ export interface Settings {
 
 const defaults: Settings = {
   projectRoots: [],
+  docRoots: [],
   claudePath: '',
   telegramBotToken: '',
   telegramChatId: '',

package/lib/telegram-bot.ts

@@ -34,7 +34,10 @@ const chatNumberedTasks = new Map<number, Map<number, string>>();
 const chatNumberedSessions = new Map<number, Map<number, { projectName: string; sessionId: string }>>();
 const chatNumberedProjects = new Map<number, Map<number, string>>();
 // Track what the last numbered list was for
-const chatListMode = new Map<number, 'tasks' | 'projects' | 'sessions'>();
+const chatListMode = new Map<number, 'tasks' | 'projects' | 'sessions' | 'task-create' | 'peek'>();
+
+// Pending task creation: waiting for prompt text
+const pendingTaskProject = new Map<number, { name: string; path: string }>();  // chatId → project
 
 // Buffer for streaming logs
 const logBuffers = new Map<string, { entries: string[]; timer: ReturnType<typeof setTimeout> | null }>();
@@ -113,6 +116,20 @@ async function handleMessage(msg: any) {
   const text: string = msg.text.trim();
   const replyTo = msg.reply_to_message?.message_id;
 
+  // Check if waiting for task prompt
+  const pending = pendingTaskProject.get(chatId);
+  if (pending && !text.startsWith('/')) {
+    pendingTaskProject.delete(chatId);
+    const task = createTask({
+      projectName: pending.name,
+      projectPath: pending.path,
+      prompt: text,
+    });
+    const msgId = await send(chatId, `✅ Task ${task.id} created\n📁 ${task.projectName}\n\n${text.slice(0, 200)}`);
+    if (msgId) { taskMessageMap.set(msgId, task.id); taskChatMap.set(task.id, chatId); }
+    return;
+  }
+
   // Check if replying to a task message → follow-up
   if (replyTo && taskMessageMap.has(replyTo)) {
     const taskId = taskMessageMap.get(replyTo)!;
@@ -125,7 +142,25 @@ async function handleMessage(msg: any) {
     const num = parseInt(text);
     const mode = chatListMode.get(chatId);
 
-    if (mode === 'projects') {
+    if (mode === 'task-create') {
+      const projMap = chatNumberedProjects.get(chatId);
+      if (projMap?.has(num)) {
+        const projectName = projMap.get(num)!;
+        const projects = scanProjects();
+        const project = projects.find(p => p.name === projectName);
+        if (project) {
+          pendingTaskProject.set(chatId, { name: project.name, path: project.path });
+          await send(chatId, `📁 ${project.name}\n\nSend the task prompt:`);
+        }
+        return;
+      }
+    } else if (mode === 'peek') {
+      const projMap = chatNumberedProjects.get(chatId);
+      if (projMap?.has(num)) {
+        await handlePeek(chatId, projMap.get(num)!);
+        return;
+      }
+    } else if (mode === 'projects') {
       const projMap = chatNumberedProjects.get(chatId);
       if (projMap?.has(num)) {
         await sendSessionList(chatId, projMap.get(num)!);
@@ -149,6 +184,9 @@ async function handleMessage(msg: any) {
 
   // Commands
   if (text.startsWith('/')) {
+    // Any new command cancels pending states
+    pendingTaskProject.delete(chatId);
+
     const [cmd, ...args] = text.split(/\s+/);
     switch (cmd) {
       case '/start':
@@ -161,7 +199,11 @@ async function handleMessage(msg: any) {
         break;
       case '/new':
       case '/task':
-        await handleNewTask(chatId, args.join(' '));
+        if (args.length > 0) {
+          await handleNewTask(chatId, args.join(' '));
+        } else {
+          await startTaskCreation(chatId);
+        }
         break;
       case '/sessions':
       case '/s':
@@ -185,6 +227,17 @@ async function handleMessage(msg: any) {
       case '/unwatch':
         await handleUnwatch(chatId, args[0]);
         break;
+      case '/peek':
+        if (args.length > 0) {
+          await handlePeek(chatId, args[0], args[1]);
+        } else {
+          await startPeekSelection(chatId);
+        }
+        break;
+      case '/docs':
+      case '/doc':
+        await handleDocs(chatId, args.join(' '));
+        break;
       case '/cancel':
         await handleCancel(chatId, args[0]);
         break;
@@ -238,6 +291,9 @@ async function sendHelp(chatId: number) {
     `/watchers — list active watchers\n` +
     `/unwatch <id> — stop watching\n\n` +
     `📝 Submit task:\nproject-name: your instructions\n\n` +
+    `👀 /peek [project] [sessionId] — session summary\n` +
+    `📖 /docs — docs session summary\n` +
+    `/docs <filename> — view doc file\n\n` +
     `🔧 /cancel <id>  /retry <id>\n` +
     `/projects — list projects\n\n` +
     `🌐 /tunnel — tunnel status\n` +
@@ -437,6 +493,167 @@ async function sendSessionContent(chatId: number, projectName: string, sessionId
   }
 }
 
+async function startPeekSelection(chatId: number) {
+  const projects = scanProjects();
+  if (projects.length === 0) {
+    await send(chatId, 'No projects configured.');
+    return;
+  }
+
+  // Filter to projects that have sessions
+  const withSessions = projects.filter(p => listClaudeSessions(p.name).length > 0);
+  if (withSessions.length === 0) {
+    await send(chatId, 'No projects with sessions found.');
+    return;
+  }
+
+  const numbered = new Map<number, string>();
+  const lines = withSessions.slice(0, 15).map((p, i) => {
+    numbered.set(i + 1, p.name);
+    const sessions = listClaudeSessions(p.name);
+    const latest = sessions[0];
+    const info = latest?.summary || latest?.firstPrompt?.slice(0, 40) || '';
+    return `${i + 1}. ${p.name}${info ? `\n   ${info}` : ''}`;
+  });
+
+  chatNumberedProjects.set(chatId, numbered);
+  chatListMode.set(chatId, 'peek');
+
+  await send(chatId, `👀 Peek — select project:\n\n${lines.join('\n')}`);
+}
+
+async function handlePeek(chatId: number, projectArg?: string, sessionArg?: string) {
+  const projects = scanProjects();
+
+  // If no project specified, use the most recent task's project
+  let projectName = projectArg;
+  let sessionId = sessionArg;
+
+  if (!projectName) {
+    // Find most recent running or done task
+    const tasks = listTasks();
+    const recent = tasks.find(t => t.status === 'running') || tasks[0];
+    if (recent) {
+      projectName = recent.projectName;
+    } else {
+      await send(chatId, 'No project specified and no recent tasks.\nUsage: /peek [project] [sessionId]');
+      return;
+    }
+  }
+
+  const project = projects.find(p => p.name === projectName || p.name.toLowerCase() === projectName!.toLowerCase());
+  if (!project) {
+    await send(chatId, `Project not found: ${projectName}`);
+    return;
+  }
+
+  // Find session
+  const sessions = listClaudeSessions(project.name);
+  if (sessions.length === 0) {
+    await send(chatId, `No sessions for ${project.name}`);
+    return;
+  }
+
+  const session = sessionId
+    ? sessions.find(s => s.sessionId.startsWith(sessionId!))
+    : sessions[0]; // most recent
+
+  if (!session) {
+    await send(chatId, `Session not found: ${sessionId}`);
+    return;
+  }
+
+  const filePath = getSessionFilePath(project.name, session.sessionId);
+  if (!filePath) {
+    await send(chatId, 'Session file not found');
+    return;
+  }
+
+  await send(chatId, `🔍 Loading ${project.name} / ${session.sessionId.slice(0, 8)}...`);
+
+  const entries = readSessionEntries(filePath);
+  if (entries.length === 0) {
+    await send(chatId, 'Session is empty');
+    return;
+  }
+
+  // Collect last N meaningful entries for raw display
+  const recentRaw: string[] = [];
+  let rawCount = 0;
+  for (let i = entries.length - 1; i >= 0 && rawCount < 8; i--) {
+    const e = entries[i];
+    if (e.type === 'user') {
+      recentRaw.unshift(`👤 ${e.content.slice(0, 300)}`);
+      rawCount++;
+    } else if (e.type === 'assistant_text') {
+      recentRaw.unshift(`🤖 ${e.content.slice(0, 300)}`);
+      rawCount++;
+    } else if (e.type === 'tool_use') {
+      recentRaw.unshift(`🔧 ${e.toolName || 'tool'}`);
+      rawCount++;
+    }
+  }
+
+  // Build context for AI summary (last ~50 entries)
+  const contextEntries: string[] = [];
+  let contextLen = 0;
+  const MAX_CONTEXT = 8000;
+  for (let i = entries.length - 1; i >= 0 && contextLen < MAX_CONTEXT; i--) {
+    const e = entries[i];
+    let line = '';
+    if (e.type === 'user') line = `User: ${e.content}`;
+    else if (e.type === 'assistant_text') line = `Assistant: ${e.content}`;
+    else if (e.type === 'tool_use') line = `Tool: ${e.toolName || 'tool'}`;
+    else continue;
+    if (contextLen + line.length > MAX_CONTEXT) break;
+    contextEntries.unshift(line);
+    contextLen += line.length;
+  }
+
+  // AI summary
+  let summary = '';
+  try {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (apiKey) {
+      const res = await fetch('https://api.anthropic.com/v1/messages', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': apiKey,
+          'anthropic-version': '2023-06-01',
+        },
+        body: JSON.stringify({
+          model: 'claude-haiku-4-5-20251001',
+          max_tokens: 500,
+          messages: [{
+            role: 'user',
+            content: `Summarize this Claude Code session in 2-3 sentences. What was the user trying to do? What's the current status? Answer in the same language as the session content.\n\n${contextEntries.join('\n')}`,
+          }],
+        }),
+      });
+      if (res.ok) {
+        const data = await res.json();
+        summary = data.content?.[0]?.text || '';
+      }
+    }
+  } catch {}
+
+  // Format output
+  const header = `📋 ${project.name} / ${session.sessionId.slice(0, 8)}\n${entries.length} entries${session.gitBranch ? ` • ${session.gitBranch}` : ''}`;
+
+  const summaryBlock = summary
+    ? `\n\n📝 Summary:\n${summary}`
+    : '';
+
+  const rawBlock = `\n\n--- Recent ---\n${recentRaw.join('\n\n')}`;
+
+  const fullText = header + summaryBlock + rawBlock;
+  const chunks = splitMessage(fullText, 4000);
+  for (const chunk of chunks) {
+    await send(chatId, chunk);
+  }
+}
+
 /**
  * Parse task creation input. Supports:
  *   project-name instructions
@@ -444,6 +661,25 @@ async function sendSessionContent(chatId: number, projectName: string, sessionId
  *   project-name -in 30m instructions
  *   project-name -at 2024-01-01T10:00 instructions
  */
+async function startTaskCreation(chatId: number) {
+  const projects = scanProjects();
+  if (projects.length === 0) {
+    await send(chatId, 'No projects configured. Add project roots in Settings.');
+    return;
+  }
+
+  const numbered = new Map<number, string>();
+  const lines = projects.slice(0, 15).map((p, i) => {
+    numbered.set(i + 1, p.name);
+    return `${i + 1}. ${p.name}`;
+  });
+
+  chatNumberedProjects.set(chatId, numbered);
+  chatListMode.set(chatId, 'task-create');
+
+  await send(chatId, `📝 New Task\n\nSelect project:\n${lines.join('\n')}`);
+}
+
 async function handleNewTask(chatId: number, input: string) {
   if (!input) {
     await send(chatId,
@@ -754,6 +990,167 @@ async function handleTunnelPassword(chatId: number, password?: string, userMsgId
   }
 }
 
+// ─── Docs ────────────────────────────────────────────────────
+
+async function handleDocs(chatId: number, input: string) {
+  const settings = loadSettings();
+  if (String(chatId) !== settings.telegramChatId) { await send(chatId, '⛔ Unauthorized'); return; }
+
+  const docRoots = (settings.docRoots || []).map((r: string) => r.replace(/^~/, require('os').homedir()));
+  if (docRoots.length === 0) {
+    await send(chatId, '⚠️ No document directories configured.\nAdd them in Settings → Document Roots');
+    return;
+  }
+
+  const docRoot = docRoots[0];
+  const { homedir: getHome } = require('os');
+  const { join, extname } = require('path');
+  const { existsSync, readFileSync, readdirSync } = require('fs');
+
+  // /docs <filename> — search and show file content
+  if (input.trim()) {
+    const query = input.trim().toLowerCase();
+
+    // Recursive search for matching .md files
+    const matches: string[] = [];
+    function searchDir(dir: string, depth: number) {
+      if (depth > 5 || matches.length >= 5) return;
+      try {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+          if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+          const full = join(dir, entry.name);
+          if (entry.isDirectory()) {
+            searchDir(full, depth + 1);
+          } else if (entry.name.toLowerCase().includes(query) && extname(entry.name) === '.md') {
+            matches.push(full);
+          }
+        }
+      } catch {}
+    }
+    searchDir(docRoot, 0);
+
+    if (matches.length === 0) {
+      await send(chatId, `No docs matching "${input.trim()}"`);
+      return;
+    }
+
+    // Show first match
+    const filePath = matches[0];
+    const relPath = filePath.replace(docRoot + '/', '');
+    try {
+      const content = readFileSync(filePath, 'utf-8');
+      const preview = content.slice(0, 3500);
+      const truncated = content.length > 3500 ? '\n\n... (truncated)' : '';
+      await send(chatId, `📄 ${relPath}\n\n${preview}${truncated}`);
+      if (matches.length > 1) {
+        const others = matches.slice(1).map(m => `  ${m.replace(docRoot + '/', '')}`).join('\n');
+        await send(chatId, `Other matches:\n${others}`);
+      }
+    } catch {
+      await send(chatId, `Failed to read: ${relPath}`);
+    }
+    return;
+  }
+
+  // /docs — show summary of latest Claude session for docs
+  const hash = docRoot.replace(/\//g, '-');
+  const claudeDir = join(getHome(), '.claude', 'projects', hash);
+
+  if (!existsSync(claudeDir)) {
+    await send(chatId, `📖 Docs: ${docRoot.split('/').pop()}\n\nNo Claude sessions yet. Open Docs tab to start.`);
+    return;
+  }
+
+  // Find latest session
+  let latestFile = '';
+  let latestTime = 0;
+  try {
+    for (const f of readdirSync(claudeDir)) {
+      if (!f.endsWith('.jsonl')) continue;
+      const { statSync } = require('fs');
+      const stat = statSync(join(claudeDir, f));
+      if (stat.mtimeMs > latestTime) {
+        latestTime = stat.mtimeMs;
+        latestFile = f;
+      }
+    }
+  } catch {}
+
+  if (!latestFile) {
+    await send(chatId, `📖 Docs: ${docRoot.split('/').pop()}\n\nNo sessions found.`);
+    return;
+  }
+
+  const sessionId = latestFile.replace('.jsonl', '');
+  const filePath = join(claudeDir, latestFile);
+
+  // Read recent entries
+  let entries: string[] = [];
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n').filter(Boolean);
+    const recentLines = lines.slice(-30);
+
+    for (const line of recentLines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === 'human' || entry.role === 'user') {
+          const text = typeof entry.message === 'string' ? entry.message : entry.message?.content?.[0]?.text || '';
+          if (text) entries.push(`👤 ${text.slice(0, 200)}`);
+        } else if (entry.type === 'assistant' && entry.message?.content) {
+          for (const block of entry.message.content) {
+            if (block.type === 'text' && block.text) {
+              entries.push(`🤖 ${block.text.slice(0, 200)}`);
+            } else if (block.type === 'tool_use') {
+              entries.push(`🔧 ${block.name || 'tool'}`);
+            }
+          }
+        }
+      } catch {}
+    }
+  } catch {}
+
+  const recent = entries.slice(-8).join('\n\n');
+  const header = `📖 Docs: ${docRoot.split('/').pop()}\n📋 Session: ${sessionId.slice(0, 12)}\n`;
+
+  // Try AI summary if available
+  let summary = '';
+  try {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (apiKey && entries.length > 2) {
+      const contextText = entries.slice(-15).join('\n');
+      const res = await fetch('https://api.anthropic.com/v1/messages', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': apiKey,
+          'anthropic-version': '2023-06-01',
+        },
+        body: JSON.stringify({
+          model: 'claude-haiku-4-5-20251001',
+          max_tokens: 300,
+          messages: [{
+            role: 'user',
+            content: `Summarize this Claude Code session in 2-3 sentences. What was the user working on? What's the current status? Answer in the same language as the content.\n\n${contextText}`,
+          }],
+        }),
+      });
+      if (res.ok) {
+        const data = await res.json();
+        summary = data.content?.[0]?.text || '';
+      }
+    }
+  } catch {}
+
+  const summaryBlock = summary ? `\n📝 ${summary}\n` : '';
+  const fullText = header + summaryBlock + '\n--- Recent ---\n' + recent;
+
+  const chunks = splitMessage(fullText, 4000);
+  for (const chunk of chunks) {
+    await send(chatId, chunk);
+  }
+}
+
 // ─── Real-time Streaming ─────────────────────────────────────
 
 function bufferLogEntry(taskId: string, chatId: number, entry: TaskLogEntry) {
@@ -877,13 +1274,15 @@ async function setBotCommands(token: string) {
       body: JSON.stringify({
         commands: [
           { command: 'tasks', description: 'List tasks' },
-          { command: 'task', description: 'Create task: /task project prompt' },
+          { command: 'task', description: 'Create task (interactive or /task project prompt)' },
           { command: 'sessions', description: 'Browse sessions' },
           { command: 'projects', description: 'List projects' },
           { command: 'tunnel', description: 'Tunnel status' },
           { command: 'tunnel_start', description: 'Start tunnel' },
           { command: 'tunnel_stop', description: 'Stop tunnel' },
           { command: 'tunnel_password', description: 'Get login password' },
+          { command: 'peek', description: 'Session summary (AI + recent)' },
+          { command: 'docs', description: 'Docs session summary / view file' },
           { command: 'watch', description: 'Monitor session' },
           { command: 'watchers', description: 'List watchers' },
           { command: 'help', description: 'Show help' },

package/lib/terminal-standalone.ts

@@ -28,7 +28,7 @@ import { WebSocketServer, WebSocket } from 'ws';
 import * as pty from 'node-pty';
 import { execSync } from 'node:child_process';
 import { homedir } from 'node:os';
-import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, mkdirSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 
 const PORT = Number(process.env.TERMINAL_PORT) || 3001;
@@ -116,6 +116,19 @@ function listTmuxSessions(): { name: string; created: string; attached: boolean;
 
 const MAX_SESSIONS = 10;
 
+function getDefaultCwd(): string {
+  try {
+    const settingsPath = join(homedir(), '.forge', 'settings.yaml');
+    const raw = readFileSync(settingsPath, 'utf-8');
+    const match = raw.match(/projectRoots:\s*\n((?:\s+-\s+.+\n?)*)/);
+    if (match) {
+      const first = match[1].split('\n').map(l => l.replace(/^\s+-\s+/, '').trim()).filter(Boolean)[0];
+      if (first) return first.replace(/^~/, homedir());
+    }
+  } catch {}
+  return homedir();
+}
+
 function createTmuxSession(cols: number, rows: number): string {
   // Auto-cleanup: if too many sessions, kill the oldest idle ones
   const existing = listTmuxSessions();
@@ -132,7 +145,7 @@ function createTmuxSession(cols: number, rows: number): string {
   const id = Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
   const name = `${SESSION_PREFIX}${id}`;
   execSync(`${TMUX} new-session -d -s ${name} -x ${cols} -y ${rows}`, {
-    cwd: homedir(),
+    cwd: getDefaultCwd(),
     env: { ...process.env, TERM: 'xterm-256color' },
   });
   // Enable mouse scrolling and set large scrollback buffer
@@ -305,7 +318,26 @@ wss.on('connection', (ws: WebSocket) => {
           const cols = parsed.cols || 120;
           const rows = parsed.rows || 30;
           try {
-            const name = createTmuxSession(cols, rows);
+            // Support fixed session name (e.g. mw-docs-claude)
+            let name: string;
+            if (parsed.sessionName && parsed.sessionName.startsWith(SESSION_PREFIX)) {
+              // Create with fixed name if it doesn't exist, otherwise attach
+              if (tmuxSessionExists(parsed.sessionName)) {
+                attachToTmux(parsed.sessionName, cols, rows);
+                break;
+              }
+              name = parsed.sessionName;
+              execSync(`${TMUX} new-session -d -s ${name} -x ${cols} -y ${rows}`, {
+                cwd: homedir(),
+                env: { ...process.env, TERM: 'xterm-256color' },
+              });
+              try {
+                execSync(`${TMUX} set-option -t ${name} mouse on 2>/dev/null`);
+                execSync(`${TMUX} set-option -t ${name} history-limit 50000 2>/dev/null`);
+              } catch {}
+            } else {
+              name = createTmuxSession(cols, rows);
+            }
             createdAt.set(ws, { session: name, time: Date.now() });
             attachToTmux(name, cols, rows);
           } catch (e: unknown) {

package/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/types/routes.d.ts";
+import "./.next/dev/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.1.10",
+  "version": "0.2.1",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {
@@ -42,6 +42,7 @@
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
     "react-markdown": "^10.1.0",
+    "remark-gfm": "^4.0.1",
     "ws": "^8.19.0",
     "yaml": "^2.8.2"
   },