@agent-spaces/server 0.3.65 → 0.4.0

package/dist/services/worktree.js

@@ -0,0 +1,207 @@
+import { v4 as uuid } from 'uuid';
+import simpleGit from 'simple-git';
+import { join } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { getDataDir, ensureDir } from '../storage/json-store.js';
+import { listWorktrees, getWorktree, createWorktree as storeCreate, updateWorktree, } from '../storage/worktree-store.js';
+import { getWorkspace, createWorkspace, deleteWorkspace, } from '../storage/workspace-store.js';
+import { broadcastToWorkspace } from '../ws/connection-manager.js';
+import { runPullRequestAgent } from '../agents/pull-request-agent.js';
+function worktreesBaseDir(workspaceId) {
+    return join(getDataDir(), 'workspaces', workspaceId, 'worktrees');
+}
+export function listWorkspaceWorktrees(workspaceId) {
+    return listWorktrees(workspaceId).filter(wt => wt.status === 'active');
+}
+export function getWorkspaceWorktree(workspaceId, worktreeId) {
+    return getWorktree(workspaceId, worktreeId);
+}
+export async function createWorkspaceWorktree(workspaceId, input) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const id = uuid();
+    let branch = input.branch || `${input.name}-${Date.now()}`;
+    const wtPath = join(worktreesBaseDir(workspaceId), id);
+    ensureDir(join(worktreesBaseDir(workspaceId)));
+    const git = simpleGit(ws.boundDirs[0]);
+    // Auto-resolve branch name conflicts
+    const branches = await git.branch();
+    let suffix = 1;
+    const baseBranch = branch;
+    while (branches.all.includes(branch)) {
+        suffix++;
+        branch = `${baseBranch}-${suffix}`;
+    }
+    await git.raw(['worktree', 'add', wtPath, '-b', branch]);
+    const now = new Date().toISOString();
+    const info = {
+        id, workspaceId, name: input.name, branch, path: wtPath,
+        agentId: input.agentId, issueId: input.issueId, taskId: input.taskId,
+        status: 'active', createdAt: now, updatedAt: now,
+    };
+    storeCreate(workspaceId, info);
+    // Write virtual workspace.json so getWorkspace(wtId) resolves for all sub-routes
+    const virtualWs = {
+        id, name: `${input.name} (Worktree)`, boundDirs: [wtPath],
+        agentspaceDir: join(wtPath, '.agentspace'),
+        isWorktree: true, parentWorkspaceId: workspaceId,
+        createdAt: now, updatedAt: now, activeChannels: [], activeIssues: [],
+    };
+    createWorkspace(virtualWs);
+    broadcastToWorkspace(workspaceId, 'worktree.created', info);
+    return info;
+}
+export async function deleteWorkspaceWorktree(workspaceId, worktreeId) {
+    const info = getWorktree(workspaceId, worktreeId);
+    if (!info)
+        throw new Error('Worktree not found');
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = simpleGit(ws.boundDirs[0]);
+    await git.raw(['worktree', 'remove', info.path, '--force']).catch(() => { });
+    // Clean up virtual workspace entry.
+    deleteWorkspace(worktreeId);
+    info.status = 'deleted';
+    info.updatedAt = new Date().toISOString();
+    updateWorktree(workspaceId, info);
+    broadcastToWorkspace(workspaceId, 'worktree.deleted', { id: worktreeId, workspaceId });
+}
+export async function getWorktreeDiff(workspaceId, worktreeId) {
+    const info = getWorktree(workspaceId, worktreeId);
+    if (!info)
+        throw new Error('Worktree not found');
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = simpleGit(ws.boundDirs[0]);
+    const defaultBranch = await getDefaultBranch(git);
+    const nameOnlyRaw = await git.diff(['--name-only', `${defaultBranch}...${info.branch}`]);
+    const files = nameOnlyRaw.split('\n').filter(Boolean);
+    const diffs = [];
+    for (const f of files) {
+        const binary = isBinaryPath(f);
+        const oldContent = binary ? '' : await git.show([`${defaultBranch}:${f}`]).catch(() => '');
+        const newContent = binary ? '' : await git.show([`${info.branch}:${f}`]).catch(() => '');
+        diffs.push({ path: f, oldContent, newContent, isBinary: binary, isNew: !oldContent, isDeleted: !newContent });
+    }
+    return diffs;
+}
+export async function createWorktreePR(workspaceId, worktreeId, title, body) {
+    const info = getWorktree(workspaceId, worktreeId);
+    if (!info)
+        throw new Error('Worktree not found');
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = simpleGit(ws.boundDirs[0]);
+    const defaultBranch = await getDefaultBranch(git);
+    const log = await git.log([`${defaultBranch}..${info.branch}`]);
+    if (log.total === 0) {
+        throw new Error('Cannot create PR: no commits on this branch. Make changes and commit first.');
+    }
+    try {
+        await git.push('origin', info.branch, ['--set-upstream']);
+    }
+    catch (e) {
+        const msg = e?.stderr || e?.message || String(e);
+        throw new Error(`Failed to push branch before creating PR: ${msg.replace(/^(Command failed: )?git\s*/, '').trim()}`);
+    }
+    const prTitle = title || `[${info.name}] ${info.branch}`;
+    const ghArgs = [
+        'pr', 'create',
+        '--base', defaultBranch,
+        '--head', info.branch,
+        '--title', prTitle,
+        '--body', body || '',
+    ];
+    let result;
+    try {
+        result = execFileSync('gh', ghArgs, { cwd: ws.boundDirs[0], encoding: 'utf-8' });
+    }
+    catch (e) {
+        const msg = e?.stderr || e?.message || String(e);
+        throw new Error(`Failed to create PR: ${msg.replace(/^(Command failed: )?gh\s*/, '').trim()}`);
+    }
+    const urlMatch = result.match(/https:\/\/[^\s]+/);
+    if (!urlMatch)
+        throw new Error('PR created but failed to parse URL from output');
+    info.prUrl = urlMatch[0];
+    info.updatedAt = new Date().toISOString();
+    updateWorktree(workspaceId, info);
+    broadcastToWorkspace(workspaceId, 'worktree.pr_created', info);
+    return info.prUrl;
+}
+export async function getWorktreePRDraft(workspaceId, worktreeId, title) {
+    const info = getWorktree(workspaceId, worktreeId);
+    if (!info)
+        throw new Error('Worktree not found');
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = simpleGit(ws.boundDirs[0]);
+    const defaultBranch = await getDefaultBranch(git);
+    const commits = await git.log([`${defaultBranch}..${info.branch}`])
+        .then((log) => log.all.map((entry) => entry.message));
+    const diff = await git.diff([`${defaultBranch}...${info.branch}`]);
+    const body = await runPullRequestAgent(workspaceId, {
+        worktree: info,
+        baseBranch: defaultBranch,
+        commits,
+        diff,
+    });
+    return {
+        title: title || `[${info.name}] ${info.branch}`,
+        body,
+        baseBranch: defaultBranch,
+    };
+}
+export async function mergeWorktreePR(workspaceId, worktreeId) {
+    const info = getWorktree(workspaceId, worktreeId);
+    if (!info)
+        throw new Error('Worktree not found');
+    if (!info.prUrl)
+        throw new Error('No PR associated with this worktree');
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = simpleGit(ws.boundDirs[0]);
+    try {
+        execFileSync('gh', ['pr', 'merge', info.prUrl, '--merge'], { cwd: ws.boundDirs[0], encoding: 'utf-8' });
+    }
+    catch (e) {
+        const msg = e?.stderr || e?.message || String(e);
+        throw new Error(`Failed to merge PR: ${msg.replace(/^(Command failed: )?gh\s*/, '').trim()}`);
+    }
+    await git.raw(['worktree', 'remove', info.path]).catch(() => { });
+    await git.raw(['branch', '-d', info.branch]).catch(() => { });
+    // Clean up virtual workspace entry.
+    deleteWorkspace(worktreeId);
+    info.status = 'merged';
+    info.updatedAt = new Date().toISOString();
+    updateWorktree(workspaceId, info);
+    broadcastToWorkspace(workspaceId, 'worktree.merged', info);
+}
+const BINARY_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp', '.avif', '.mp3', '.mp4', '.zip', '.gz', '.tar', '.woff', '.woff2', '.ttf', '.eot', '.pdf', '.wasm']);
+function isBinaryPath(filePath) {
+    const ext = filePath.slice(filePath.lastIndexOf('.')).toLowerCase();
+    return BINARY_EXTS.has(ext);
+}
+async function getDefaultBranch(git) {
+    try {
+        const result = await git.raw(['symbolic-ref', 'refs/remotes/origin/HEAD']);
+        const match = result.match(/refs\/remotes\/origin\/(.+)/);
+        if (match)
+            return match[1].trim();
+    }
+    catch { }
+    // Fallback: try common names
+    const branches = await git.branch();
+    if (branches.all.includes('main'))
+        return 'main';
+    if (branches.all.includes('master'))
+        return 'master';
+    return 'main';
+}
+//# sourceMappingURL=worktree.js.map

package/dist/storage/agent-store.js

@@ -149,6 +149,7 @@ export function getAgentUsageDashboard(days = 30) {
         dailyMap.set(key, {
             date: key,
             label: date.toLocaleDateString('en-US', { weekday: 'short' }),
+            requests: 0,
             inputTokens: 0,
             outputTokens: 0,
             totalTokens: 0,
@@ -161,6 +162,7 @@ export function getAgentUsageDashboard(days = 30) {
     for (const record of records) {
         const day = dailyMap.get(record.completedAt.slice(0, 10));
         if (day) {
+            day.requests += 1;
             day.inputTokens += record.inputTokens + record.cachedInputTokens;
             day.outputTokens += record.outputTokens + record.reasoningTokens;
             day.totalTokens += record.totalTokens;
@@ -323,4 +325,10 @@ function findConfiguredModelCost(model) {
         outputPerMillion: toMoney(configured.cost.outputPerMillion),
     };
 }
+export function closeDb() {
+    if (db) {
+        db.close();
+        db = null;
+    }
+}
 //# sourceMappingURL=agent-store.js.map

package/dist/storage/chat-store.js

@@ -0,0 +1,151 @@
+import { getDataDir, ensureDir, readJsonFile, writeJsonFile, deleteFile } from './json-store.js';
+import path from 'node:path';
+import { existsSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+function chatDir() {
+    return path.join(getDataDir(), 'chat');
+}
+function chatTemplatesDir() {
+    return path.join(getDataDir(), 'chat-templates');
+}
+export function agentDir(agentId) {
+    return path.join(chatTemplatesDir(), agentId);
+}
+function agentFile(agentId) {
+    return path.join(agentDir(agentId), 'agent.json');
+}
+function mcpFile(agentId) {
+    return path.join(agentDir(agentId), 'mcp.json');
+}
+function skillsDir(agentId) {
+    return path.join(agentDir(agentId), 'skills');
+}
+export function chatSessionDir(chatId) {
+    return path.join(chatDir(), chatId);
+}
+export function chatWorkspaceDir(chatId) {
+    return path.join(chatSessionDir(chatId), 'workspaces');
+}
+function chatWorkspaceSkillsDir(chatId) {
+    return path.join(chatWorkspaceDir(chatId), 'skills');
+}
+export function messageHistoryDir(agentId) {
+    return chatSessionDir(agentId);
+}
+function messagesFile(chatId) {
+    return path.join(chatSessionDir(chatId), 'messages.json');
+}
+// --- Agent functions ---
+export function listAgents() {
+    ensureDir(chatTemplatesDir());
+    return readdirSync(chatTemplatesDir(), { withFileTypes: true })
+        .filter(entry => entry.isDirectory())
+        .flatMap(entry => {
+        const agent = readJsonFile(agentFile(entry.name));
+        return agent ? [agent] : [];
+    })
+        .sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+export function saveAgent(agent, skillInputs) {
+    const dir = agentDir(agent.id);
+    ensureDir(dir);
+    ensureDir(skillsDir(agent.id));
+    ensureDir(chatWorkspaceDir(agent.id));
+    ensureDir(chatWorkspaceSkillsDir(agent.id));
+    writeJsonFile(agentFile(agent.id), agent);
+    writeJsonFile(mcpFile(agent.id), agent.mcps ?? {});
+    writeSkills(agent.id, skillInputs, agent.skills ?? []);
+}
+export function findAgent(id) {
+    return readJsonFile(agentFile(id)) ?? undefined;
+}
+export function deleteAgent(id) {
+    rmSync(agentDir(id), { recursive: true, force: true });
+    rmSync(chatSessionDir(id), { recursive: true, force: true });
+}
+// --- Message functions ---
+export function listMessages(agentId, limit, before) {
+    ensureDir(chatSessionDir(agentId));
+    let messages = readJsonFile(messagesFile(agentId)) ?? [];
+    messages = messages.filter(msg => msg.agentId === agentId);
+    // Sort descending by timestamp
+    messages.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    // Cursor pagination: skip messages at or after 'before' timestamp
+    if (before) {
+        const idx = messages.findIndex(m => m.timestamp <= before);
+        if (idx === -1) {
+            messages = [];
+        }
+        else {
+            messages = messages.slice(idx);
+        }
+    }
+    // Apply limit
+    if (limit && limit > 0) {
+        messages = messages.slice(0, limit);
+    }
+    // Return ascending order
+    messages.reverse();
+    return messages;
+}
+export function saveMessage(msg) {
+    const messages = readJsonFile(messagesFile(msg.agentId)) ?? [];
+    messages.push(msg);
+    writeJsonFile(messagesFile(msg.agentId), messages);
+}
+export function deleteMessagesByAgent(agentId) {
+    deleteFile(messagesFile(agentId));
+}
+export function getRecentMessages(agentId, limit = 50) {
+    return listMessages(agentId, limit);
+}
+function writeSkills(agentId, skillInputs, skillNames) {
+    const dir = skillsDir(agentId);
+    if (skillInputs?.some(skill => typeof skill !== 'string')) {
+        rmSync(dir, { recursive: true, force: true });
+        ensureDir(dir);
+        for (const skill of skillInputs) {
+            if (typeof skill === 'string' || !skill.name.trim())
+                continue;
+            const filename = sanitizeMarkdownFilename(skill.name);
+            const content = skill.content ?? readSkillContent(skill.name) ?? '';
+            writeJsonSkillFile(path.join(dir, filename), content);
+            writeJsonSkillFile(path.join(chatWorkspaceSkillsDir(agentId), filename), content);
+        }
+        return;
+    }
+    for (const name of skillNames.map(skill => typeof skill === 'string' ? skill : skill.name)) {
+        const filename = sanitizeMarkdownFilename(name);
+        const content = readSkillContent(name) ?? '';
+        const filePath = path.join(dir, filename);
+        if (content || !existsSync(filePath))
+            writeJsonSkillFile(filePath, content);
+        const workspaceSkillPath = path.join(chatWorkspaceSkillsDir(agentId), filename);
+        if (content || !existsSync(workspaceSkillPath))
+            writeJsonSkillFile(workspaceSkillPath, content);
+    }
+}
+function writeJsonSkillFile(filePath, content) {
+    ensureDir(path.dirname(filePath));
+    writeFileSync(filePath, content, 'utf-8');
+}
+function sanitizeMarkdownFilename(name) {
+    const base = name.trim().replace(/[/\\:*?"<>|]+/g, '-');
+    return base.toLowerCase().endsWith('.md') ? base : `${base}.md`;
+}
+function readSkillContent(name) {
+    const skillName = name.trim().replace(/\.md$/i, '');
+    if (!skillName)
+        return undefined;
+    const candidates = [
+        path.join(getDataDir(), 'skills', skillName, 'SKILL.md'),
+        path.join(getDataDir(), 'skills', `${skillName}.md`),
+        path.join(process.cwd(), 'skills', skillName, 'SKILL.md'),
+        path.join(process.cwd(), 'skills', `${skillName}.md`),
+    ];
+    const source = candidates.find(file => existsSync(file));
+    if (!source)
+        return undefined;
+    const content = readFileSync(source, 'utf-8');
+    return content.trim() ? content : undefined;
+}
+//# sourceMappingURL=chat-store.js.map

package/dist/storage/database-store.js

@@ -362,4 +362,10 @@ export function listDatabaseEmbeddings(workspaceId, databaseId) {
         embedding: JSON.parse(row.embedding),
     }));
 }
+export function closeDb() {
+    if (db) {
+        db.close();
+        db = null;
+    }
+}
 //# sourceMappingURL=database-store.js.map

package/dist/storage/json-store.js

@@ -1,6 +1,7 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from 'node:fs';
 import { join, dirname } from 'node:path';
-const DEFAULT_DATA_DIR = join(process.env.HOME || '~', '.agent-spaces-data');
+import { homedir } from 'node:os';
+const DEFAULT_DATA_DIR = join(process.env.HOME || process.env.USERPROFILE || homedir(), '.agent-spaces-data');
 export function getDataDir() {
     return process.env.AGENT_SPACES_DATA_DIR || DEFAULT_DATA_DIR;
 }

package/dist/storage/kanban-store.js

@@ -139,4 +139,10 @@ export function saveTasks(boardId, tasks) {
     }
     database.prepare('UPDATE kanban_boards SET updated_at = ? WHERE id = ?').run(Date.now(), boardId);
 }
+export function closeDb() {
+    if (db) {
+        db.close();
+        db = null;
+    }
+}
 //# sourceMappingURL=kanban-store.js.map