@agent-spaces/server 0.1.0

package/dist/adapters/git.js

@@ -0,0 +1,335 @@
+import { simpleGit } from 'simple-git';
+import { getWorkspace } from '../storage/workspace-store.js';
+import { writeFile, readFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, basename } from 'node:path';
+const gitInstances = new Map();
+function getGitOptions() {
+    const proxy = process.env.HTTPS_PROXY || process.env.https_proxy
+        || process.env.HTTP_PROXY || process.env.http_proxy;
+    const config = [];
+    if (proxy) {
+        config.push(`http.proxy=${proxy}`, `https.proxy=${proxy}`);
+    }
+    return config.length ? { config } : {};
+}
+function getGit(workspace) {
+    const existing = gitInstances.get(workspace.id);
+    if (existing)
+        return existing;
+    const git = simpleGit(workspace.boundDirs[0], getGitOptions());
+    git.outputHandler((_binary, stdout, stderr) => {
+        stderr.on('data', (chunk) => {
+            const text = chunk.toString().trim();
+            if (text)
+                console.log(`[git:${workspace.id}] ${text}`);
+        });
+        stdout.on('data', (chunk) => {
+            const text = chunk.toString().trim();
+            if (text)
+                console.log(`[git:${workspace.id}] ${text}`);
+        });
+    });
+    gitInstances.set(workspace.id, git);
+    return git;
+}
+function mapStatus(raw) {
+    const files = [];
+    for (const f of raw.staged) {
+        files.push({ path: f, status: mapStatusCode(raw.files.find(r => r.path === f)?.index) });
+    }
+    for (const f of raw.modified) {
+        if (!files.find(x => x.path === f)) {
+            files.push({ path: f, status: 'modified' });
+        }
+    }
+    for (const f of raw.not_added) {
+        files.push({ path: f, status: 'untracked' });
+    }
+    for (const f of raw.deleted) {
+        if (!files.find(x => x.path === f)) {
+            files.push({ path: f, status: 'deleted' });
+        }
+    }
+    for (const f of raw.created) {
+        if (!files.find(x => x.path === f)) {
+            files.push({ path: f, status: 'added' });
+        }
+    }
+    return {
+        branch: raw.current || 'HEAD',
+        files,
+        ahead: raw.ahead,
+        behind: raw.behind,
+        clean: raw.isClean(),
+    };
+}
+function mapStatusCode(code) {
+    switch (code) {
+        case 'A': return 'added';
+        case 'D': return 'deleted';
+        case 'R': return 'renamed';
+        case 'M': return 'modified';
+        default: return 'modified';
+    }
+}
+export async function gitStatus(workspaceId) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    const raw = await git.status();
+    return mapStatus(raw);
+}
+export async function gitDiff(workspaceId, filePath) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    const diffs = [];
+    if (filePath) {
+        const diff = await git.diff([filePath]);
+        const oldContent = await git.show([`HEAD:${filePath}`]).catch(() => '');
+        const newContent = await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${filePath}`, 'utf-8')).catch(() => '');
+        diffs.push({
+            path: filePath,
+            oldContent,
+            newContent,
+            isBinary: false,
+            isNew: !oldContent,
+            isDeleted: !newContent,
+        });
+    }
+    else {
+        const raw = await git.diff(['--name-only']);
+        const files = raw.split('\n').filter(Boolean);
+        for (const f of files) {
+            const oldContent = await git.show([`HEAD:${f}`]).catch(() => '');
+            const newContent = await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${f}`, 'utf-8')).catch(() => '');
+            diffs.push({
+                path: f,
+                oldContent,
+                newContent,
+                isBinary: false,
+                isNew: !oldContent,
+                isDeleted: !newContent,
+            });
+        }
+        // Also check untracked (staged new files)
+        const status = await git.status();
+        for (const f of status.not_added) {
+            const newContent = await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${f}`, 'utf-8')).catch(() => '');
+            if (newContent) {
+                diffs.push({
+                    path: f,
+                    oldContent: '',
+                    newContent,
+                    isBinary: false,
+                    isNew: true,
+                    isDeleted: false,
+                });
+            }
+        }
+    }
+    return diffs;
+}
+export async function gitLog(workspaceId, maxCount = 50) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    const log = await git.log({ maxCount });
+    return log.all.map(entry => ({
+        hash: entry.hash.substring(0, 7),
+        message: entry.message,
+        author: entry.author_name,
+        date: entry.date,
+    }));
+}
+export async function gitCommit(workspaceId, message) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    await git.add('-A');
+    const result = await git.commit(message);
+    return { hash: result.commit };
+}
+export async function gitDiscard(workspaceId, filePath) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    await git.checkout(['--', filePath]);
+}
+export async function gitDiscardAll(workspaceId) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    await git.checkout(['--', '.']);
+    await git.clean('f', ['-d']);
+}
+export async function gitBranches(workspaceId) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    const raw = await git.branch();
+    return raw.all.map(name => ({
+        name,
+        current: name === raw.current,
+    }));
+}
+export async function gitCheckout(workspaceId, branch) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    await git.checkout(branch);
+}
+const DEFAULT_GITIGNORE = `node_modules/
+dist/
+.env
+.env.local
+.env.*.local
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Logs
+*.log
+npm-debug.log*
+
+# Coverage
+coverage/
+
+# Agent Spaces
+.agentspace/
+`;
+export async function gitGenerateCommitMsg(workspaceId) {
+    const { runCommitAgent } = await import('../agents/commit-agent.js');
+    return runCommitAgent(workspaceId);
+}
+export async function gitPush(workspaceId) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    const status = await git.status();
+    const branch = status.current || 'HEAD';
+    const remotes = await git.getRemotes(true);
+    if (!remotes.length)
+        throw new Error('No remote repository configured. Please add a remote first.');
+    await git.push('origin', branch);
+}
+export async function gitPull(workspaceId) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    const status = await git.status();
+    const branch = status.current || 'HEAD';
+    await git.pull('origin', branch);
+}
+export async function gitGetRemotes(workspaceId) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    return git.getRemotes(true);
+}
+export async function gitAddRemote(workspaceId, name, url) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const git = getGit(ws);
+    const remotes = await git.getRemotes();
+    if (remotes.some(r => r.name === name)) {
+        await git.remote(['set-url', name, url]);
+    }
+    else {
+        await git.addRemote(name, url);
+    }
+}
+export async function gitInit(workspaceId) {
+    const ws = getWorkspace(workspaceId);
+    if (!ws)
+        throw new Error('Workspace not found');
+    const rootDir = ws.boundDirs[0];
+    const git = simpleGit(rootDir, getGitOptions());
+    await git.init();
+    const gitignorePath = join(rootDir, '.gitignore');
+    try {
+        const existing = await readFile(gitignorePath, 'utf-8');
+        if (!existing.includes('.agentspace')) {
+            await writeFile(gitignorePath, existing.trimEnd() + '\n\n# Agent Spaces\n.agentspace/\n', 'utf-8');
+        }
+    }
+    catch {
+        await writeFile(gitignorePath, DEFAULT_GITIGNORE, 'utf-8');
+    }
+    gitInstances.delete(workspaceId);
+}
+export async function gitClone(targetDir, url, onProgress) {
+    if (!existsSync(targetDir)) {
+        await mkdir(targetDir, { recursive: true });
+    }
+    const repoName = basename(url, '.git').replace(/\.git$/, '') || 'repo';
+    const cloneDir = join(targetDir, repoName);
+    if (existsSync(cloneDir)) {
+        throw new Error(`目录 ${cloneDir} 已存在`);
+    }
+    const git = simpleGit(getGitOptions());
+    git.outputHandler((_binary, stdout, stderr) => {
+        stderr.on('data', (chunk) => {
+            const text = chunk.toString();
+            console.log(`[git:clone] ${text.trim()}`);
+            const parsed = parseCloneProgress(text);
+            if (parsed)
+                onProgress(parsed);
+        });
+        stdout.on('data', (chunk) => {
+            const text = chunk.toString().trim();
+            if (text)
+                console.log(`[git:clone] ${text}`);
+        });
+    });
+    await git.clone(url, cloneDir, ['--progress']);
+    return cloneDir;
+}
+function parseCloneProgress(text) {
+    // git --progress 输出用 \r 覆盖，可能有多个阶段在同一段文本中
+    const lines = text.split('\r').filter(Boolean);
+    let result = null;
+    for (const line of lines) {
+        const m = line.match(/Counting objects:\s*(\d+)%\s*\((\d+)\/(\d+)\)/) ||
+            line.match(/Compressing objects:\s*(\d+)%\s*\((\d+)\/(\d+)\)/) ||
+            line.match(/Receiving objects:\s*(\d+)%\s*\((\d+)\/(\d+)\)/) ||
+            line.match(/Resolving deltas:\s*(\d+)%\s*\((\d+)\/(\d+)\)/);
+        if (m) {
+            const phaseMap = {
+                Counting: 'counting',
+                Compressing: 'compressing',
+                Receiving: 'receiving',
+                Resolving: 'resolving',
+            };
+            const keyword = m[0].split(' ')[0];
+            result = {
+                phase: phaseMap[keyword] || 'receiving',
+                progress: parseInt(m[1]),
+                received: parseInt(m[2]),
+                total: parseInt(m[3]),
+            };
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=git.js.map

package/dist/adapters/open-agent-sdk-runtime.js

@@ -0,0 +1,87 @@
+import { createAgent } from '@codeany/open-agent-sdk';
+import { summarizeResult } from './agent-runtime-types.js';
+/**
+ * Runtime backed by @codeany/open-agent-sdk.
+ * Runs the agent loop in-process with the SDK's built-in tools.
+ */
+export class OpenAgentSdkRuntime {
+    config;
+    agent = null;
+    abortController = null;
+    constructor(config = {}) {
+        this.config = config;
+    }
+    async execute(prompt, workingDir, options) {
+        this.abortController = new AbortController();
+        const output = [];
+        const cwd = workingDir || process.cwd();
+        const startTime = Date.now();
+        const d = (msg) => console.log(`[agent] ${msg}`);
+        d(`starting | cwd=${cwd} provider=${this.config.provider ?? 'default'} model=${this.config.model ?? 'default'} baseURL=${this.config.baseURL ?? 'default'} permissionMode=${this.config.permissionMode ?? 'bypassPermissions'} maxTurns=${options?.maxTurns ?? '∞'} tools=${options?.tools?.join(',') ?? 'all'} sandboxDirs=${options?.sandboxDirs?.join(',') ?? '-'}`);
+        d(`prompt: ${prompt.slice(0, 300)}${prompt.length > 300 ? '...' : ''}`);
+        try {
+            this.agent = createAgent({
+                apiType: normalizeApiType(this.config.provider),
+                model: this.config.model,
+                apiKey: this.config.apiKey,
+                baseURL: this.config.baseURL,
+                cwd,
+                systemPrompt: options?.systemPrompt,
+                maxTurns: options?.maxTurns,
+                allowedTools: options?.tools,
+                additionalDirectories: options?.sandboxDirs,
+                permissionMode: this.config.permissionMode ?? 'bypassPermissions',
+                abortController: this.abortController,
+            });
+            d('agent created, sending prompt...');
+            d('tool debug | open-agent-sdk runtime does not expose per-tool stream events through prompt(); only final text/usage is available here');
+            const result = await this.agent.prompt(prompt);
+            const elapsed = Date.now() - startTime;
+            const inputTokens = result.usage.input_tokens;
+            const outputTokens = result.usage.output_tokens;
+            const usage = result.usage;
+            const cacheRead = usage.cache_read_input_tokens ?? 0;
+            const cacheCreation = usage.cache_creation_input_tokens ?? 0;
+            output.push(result.text);
+            output.push(`[Usage] tokens=${inputTokens + outputTokens + Number(cacheRead) + Number(cacheCreation)} input=${inputTokens} output=${outputTokens} cached=${Number(cacheRead) + Number(cacheCreation)}`);
+            options?.onEvent?.({ type: 'output', line: result.text });
+            d(`done ${elapsed}ms | turns=${result.num_turns} tokens=${inputTokens + outputTokens} (in=${inputTokens} out=${outputTokens})${Number(cacheRead) > 0 || Number(cacheCreation) > 0 ? ` cache=(read=${cacheRead},create=${cacheCreation})` : ''}`);
+            return {
+                success: true,
+                summary: summarizeResult(result.text),
+                artifacts: [],
+                output,
+                usage: {
+                    inputTokens,
+                    outputTokens,
+                    cachedInputTokens: Number(cacheRead) + Number(cacheCreation),
+                    totalTokens: inputTokens + outputTokens + Number(cacheRead) + Number(cacheCreation),
+                },
+            };
+        }
+        catch (err) {
+            const elapsed = Date.now() - startTime;
+            const message = err instanceof Error ? err.message : String(err);
+            d(`failed ${elapsed}ms | ${message}`);
+            if (err instanceof Error && err.stack)
+                console.error(err.stack);
+            return { success: false, summary: 'Agent execution failed', artifacts: [], error: message, output };
+        }
+        finally {
+            await this.agent?.close();
+            this.agent = null;
+            this.abortController = null;
+        }
+    }
+    stop() {
+        this.abortController?.abort();
+        this.agent?.interrupt();
+    }
+}
+function normalizeApiType(provider) {
+    if (provider === 'anthropic-messages' || provider === 'openai-completions') {
+        return provider;
+    }
+    return undefined;
+}
+//# sourceMappingURL=open-agent-sdk-runtime.js.map

package/dist/agents/agent-context.js

@@ -0,0 +1,6 @@
+/**
+ * Shared agent context — passed between agents and hooks.
+ * Provides broadcast, task/issue mutation, and runtime creation.
+ */
+export {};
+//# sourceMappingURL=agent-context.js.map