@aigencydev/cli 0.3.9 → 0.5.0

package/dist/commands/chat.js

@@ -10,6 +10,7 @@ import { ensureProjectDataDirs } from "../config/bootstrap.js";
 import { fetchMe } from "../api-client/auth.js";
 import { App } from "../ui/App.js";
 import { log } from "../utils/logger.js";
+import { findLatestSession, loadChatHistoryFromSession, } from "../agent/session-store.js";
 async function findProjectRoot(cwd) {
     const markers = [
         ".git",
@@ -73,15 +74,71 @@ export async function runChatCommand(options = {}) {
     const priorInsights = [instructions.combinedText, memory.summary]
         .filter((s) => s && s.trim())
         .join("\n\n---\n\n");
+    let restoredHistory = [];
+    let restoredSessionId;
+    let continuePrompt;
+    if (options.continueLastSession || options.resumeSessionId) {
+        try {
+            let targetSessionId;
+            if (options.resumeSessionId) {
+                targetSessionId = options.resumeSessionId;
+                log.info(`Session restore: ${targetSessionId}`);
+            }
+            else {
+                const latest = await findLatestSession(projectRoot);
+                if (latest) {
+                    targetSessionId = latest.sessionId;
+                    log.info(`Son session bulundu: ${targetSessionId}`);
+                }
+            }
+            if (targetSessionId) {
+                const history = await loadChatHistoryFromSession(targetSessionId, projectRoot);
+                if (history.length > 0) {
+                    restoredHistory = history;
+                    restoredSessionId = targetSessionId;
+                    if (!options.prompt) {
+                        continuePrompt =
+                            "Kaldığım yerden devam ediyorum. Önce read_tasks ile mevcut plana bak, " +
+                                "pending ve in_progress task'leri sıraya göre tamamla. " +
+                                "Tüm task'lar completed olana kadar durma.";
+                    }
+                    log.info(`${history.length} mesaj restore edildi`);
+                }
+                else {
+                    log.warn("Session bulundu ama boş — yeni oturum başlatılıyor");
+                }
+            }
+            else {
+                log.warn("Devam edilecek session bulunamadı — yeni oturum başlatılıyor");
+            }
+        }
+        catch (err) {
+            log.warn(`Session restore hatası: ${err.message}`);
+        }
+    }
+    let finalInsights = priorInsights;
+    if (restoredHistory.length > 0) {
+        const historyBlock = restoredHistory
+            .map((m) => `[${m.role === "user" ? "Kullanıcı" : "Asistan"}]: ${m.content.slice(0, 500)}`)
+            .slice(-20)
+            .join("\n\n");
+        finalInsights = [
+            priorInsights,
+            `## ÖNCEKİ OTURUM (${restoredSessionId || "bilinmiyor"})\nAşağıda önceki oturumdan devam edilen konuşma özeti var:\n\n${historyBlock}`,
+        ]
+            .filter((s) => s && s.trim())
+            .join("\n\n---\n\n");
+        log.info(`Session history priorInsights'a enjekte edildi (${restoredHistory.length} mesaj)`);
+    }
     const { waitUntilExit } = render(React.createElement(App, {
         session,
         initialMode: mode,
         initialModel: model,
         cwd,
         projectRoot,
-        initialPrompt: options.prompt,
+        initialPrompt: continuePrompt || options.prompt,
         settings,
-        memorySummary: priorInsights,
+        memorySummary: finalInsights,
     }), {
         exitOnCtrlC: false,
     });

package/dist/commands/mcp-server.js

@@ -0,0 +1,4 @@
+import { startMcpServer } from "../mcp/server.js";
+export async function runMcpServerCommand() {
+    await startMcpServer();
+}

package/dist/config/defaults.js

@@ -39,5 +39,19 @@ export const SettingsSchema = z.object({
         theme: z.enum(["dark", "auto"]).default("auto"),
     })
         .default({ theme: "auto" }),
+    mcp: z
+        .object({
+        servers: z
+            .array(z.object({
+            name: z.string().regex(/^[a-z0-9_-]+$/),
+            command: z.string(),
+            args: z.array(z.string()).default([]),
+            env: z.record(z.string()).default({}),
+            autoStart: z.boolean().default(true),
+            enabled: z.boolean().default(true),
+        }))
+            .default([]),
+    })
+        .default({ servers: [] }),
 });
 export const DEFAULT_SETTINGS = SettingsSchema.parse({});

package/dist/mcp/client-manager.js

@@ -0,0 +1,156 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { log } from "../utils/logger.js";
+export class McpClientManager {
+    servers = new Map();
+    async startAll(configs) {
+        const eligible = configs.filter((c) => c.enabled && c.autoStart);
+        if (eligible.length === 0)
+            return;
+        log.info(`MCP: ${eligible.length} server başlatılıyor...`);
+        const results = await Promise.allSettled(eligible.map((c) => this.startServer(c)));
+        let ready = 0;
+        for (const r of results) {
+            if (r.status === "fulfilled")
+                ready++;
+        }
+        log.info(`MCP: ${ready}/${eligible.length} server hazır`);
+    }
+    async startServer(config) {
+        if (this.servers.has(config.name)) {
+            log.warn(`MCP: ${config.name} zaten çalışıyor, atlanıyor`);
+            return;
+        }
+        const instance = {
+            name: config.name,
+            config,
+            client: null,
+            transport: null,
+            tools: [],
+            status: "starting",
+        };
+        this.servers.set(config.name, instance);
+        try {
+            const transport = new StdioClientTransport({
+                command: config.command,
+                args: config.args,
+                env: { ...process.env, ...config.env },
+            });
+            const client = new Client({ name: "aigency-cli", version: "1.0.0" }, { capabilities: {} });
+            instance.transport = transport;
+            instance.client = client;
+            await client.connect(transport);
+            const toolsResult = await client.listTools();
+            instance.tools = (toolsResult.tools || []).map((t) => ({
+                qualifiedName: `mcp_${config.name}_${t.name}`,
+                originalName: t.name,
+                serverName: config.name,
+                description: t.description || "",
+                inputSchema: t.inputSchema || { type: "object", properties: {} },
+            }));
+            instance.status = "ready";
+            log.info(`MCP: ${config.name} hazır (${instance.tools.length} tool)`);
+        }
+        catch (err) {
+            instance.status = "error";
+            instance.error = err.message;
+            log.error(`MCP: ${config.name} başlatılamadı: ${instance.error}`);
+        }
+    }
+    async stopAll() {
+        const names = [...this.servers.keys()];
+        await Promise.allSettled(names.map((n) => this.stopServer(n)));
+        this.servers.clear();
+    }
+    async stopServer(name) {
+        const instance = this.servers.get(name);
+        if (!instance)
+            return;
+        try {
+            await instance.client?.close();
+        }
+        catch {
+        }
+        instance.status = "stopped";
+        this.servers.delete(name);
+        log.debug(`MCP: ${name} durduruldu`);
+    }
+    getAllTools() {
+        const tools = [];
+        for (const instance of this.servers.values()) {
+            if (instance.status === "ready") {
+                tools.push(...instance.tools);
+            }
+        }
+        return tools;
+    }
+    toLlmTools() {
+        return this.getAllTools().map((t) => ({
+            type: "function",
+            function: {
+                name: t.qualifiedName,
+                description: `[MCP: ${t.serverName}] ${t.description}`,
+                parameters: t.inputSchema,
+            },
+        }));
+    }
+    async callTool(qualifiedName, params) {
+        const start = Date.now();
+        const match = qualifiedName.match(/^mcp_([^_]+)_(.+)$/);
+        if (!match) {
+            return {
+                success: false,
+                output: "",
+                error: `Geçersiz MCP tool adı: ${qualifiedName}`,
+                duration: Date.now() - start,
+            };
+        }
+        const serverName = match[1];
+        const toolName = match[2];
+        const instance = this.servers.get(serverName);
+        if (!instance || instance.status !== "ready") {
+            return {
+                success: false,
+                output: "",
+                error: `MCP server '${serverName}' hazır değil`,
+                duration: Date.now() - start,
+            };
+        }
+        try {
+            const result = await instance.client.callTool({
+                name: toolName,
+                arguments: params,
+            });
+            const textContent = result.content
+                ?.filter((c) => c.type === "text")
+                ?.map((c) => c.text)
+                ?.join("\n") || "";
+            return {
+                success: !result.isError,
+                output: textContent,
+                error: result.isError ? textContent.slice(0, 200) : undefined,
+                metadata: { mcpServer: serverName, mcpTool: toolName },
+                duration: Date.now() - start,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: "",
+                error: `MCP çağrı hatası: ${err.message.slice(0, 150)}`,
+                duration: Date.now() - start,
+            };
+        }
+    }
+    getStatuses() {
+        return [...this.servers.values()].map((s) => ({
+            name: s.name,
+            status: s.status,
+            toolCount: s.tools.length,
+            error: s.error,
+        }));
+    }
+    hasTools() {
+        return this.getAllTools().length > 0;
+    }
+}

package/dist/mcp/server.js

@@ -0,0 +1,46 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ListToolsRequestSchema, CallToolRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { dispatchLocalTool } from "../tools/registry.js";
+import { EXPOSED_TOOL_SCHEMAS } from "../tools/metadata.js";
+const CLI_VERSION = "0.4.0";
+export async function startMcpServer() {
+    const server = new Server({ name: "aigency-cli", version: CLI_VERSION }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: EXPOSED_TOOL_SCHEMAS.map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.parameters,
+        })),
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const isExposed = EXPOSED_TOOL_SCHEMAS.some((t) => t.name === name);
+        if (!isExposed) {
+            return {
+                content: [{ type: "text", text: `Tool '${name}' MCP üzerinden erişilemez` }],
+                isError: true,
+            };
+        }
+        const ctx = {
+            cwd: process.cwd(),
+            projectRoot: process.cwd(),
+            mode: "accept_edits",
+        };
+        try {
+            const result = await dispatchLocalTool(name, (args || {}), ctx);
+            return {
+                content: [{ type: "text", text: result.output || result.error || "(boş)" }],
+                isError: !result.success,
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Hata: ${err.message.slice(0, 200)}` }],
+                isError: true,
+            };
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/dist/mcp/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tools/check-dependencies.js

@@ -0,0 +1,149 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+const SYSTEM_DEPS = [
+    { name: "node", command: "node", required: true, versionFlag: "--version" },
+    { name: "npm", command: "npm", required: true, versionFlag: "--version" },
+    { name: "git", command: "git", required: false, versionFlag: "--version" },
+    { name: "python3", command: os.platform() === "win32" ? "python" : "python3", required: false, versionFlag: "--version" },
+    { name: "docker", command: "docker", required: false, versionFlag: "--version" },
+];
+function getInstallHint(name, platform) {
+    const hints = {
+        node: {
+            win32: "choco install nodejs-lts  veya  https://nodejs.org",
+            darwin: "brew install node",
+            linux: "sudo apt install nodejs npm  veya  https://nodejs.org",
+        },
+        npm: {
+            win32: "Node.js ile birlikte gelir — node kur",
+            darwin: "Node.js ile birlikte gelir — brew install node",
+            linux: "Node.js ile birlikte gelir — sudo apt install nodejs npm",
+        },
+        git: {
+            win32: "choco install git  veya  https://git-scm.com",
+            darwin: "xcode-select --install  veya  brew install git",
+            linux: "sudo apt install git",
+        },
+        python3: {
+            win32: "choco install python  veya  https://python.org",
+            darwin: "brew install python3",
+            linux: "sudo apt install python3",
+        },
+        docker: {
+            win32: "https://docs.docker.com/desktop/install/windows-install/",
+            darwin: "brew install --cask docker",
+            linux: "sudo apt install docker.io docker-compose",
+        },
+    };
+    return hints[name]?.[platform] || `${name} kurulumu için dökümantasyona bakın`;
+}
+function checkCommand(command, versionFlag) {
+    try {
+        const result = execSync(`${command} ${versionFlag}`, {
+            timeout: 5000,
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        return result.trim().split("\n")[0] || "kurulu";
+    }
+    catch {
+        return null;
+    }
+}
+export const checkDependenciesHandler = async (params, ctx) => {
+    const start = Date.now();
+    const projectPath = (params.path || params.projectPath || ".");
+    const resolved = path.resolve(ctx.cwd, projectPath);
+    const platform = os.platform();
+    const results = [];
+    const missing = [];
+    const warnings = [];
+    results.push("## Sistem Bağımlılıkları\n");
+    results.push(`Platform: ${platform} (${os.arch()})`);
+    results.push(`Node sürümü gereksinimi: >= 18.18.0\n`);
+    for (const dep of SYSTEM_DEPS) {
+        const version = checkCommand(dep.command, dep.versionFlag);
+        if (version) {
+            results.push(`✓ ${dep.name}: ${version}`);
+            if (dep.name === "node") {
+                const match = version.match(/v?(\d+)\.(\d+)/);
+                if (match) {
+                    const major = parseInt(match[1], 10);
+                    const minor = parseInt(match[2], 10);
+                    if (major < 18 || (major === 18 && minor < 18)) {
+                        warnings.push(`Node.js ${version} çok eski — 18.18+ gerekli`);
+                    }
+                }
+            }
+        }
+        else {
+            const status = dep.required ? "✗ (ZORUNLU)" : "✗ (opsiyonel)";
+            results.push(`${status} ${dep.name}: kurulu değil`);
+            results.push(`  → ${getInstallHint(dep.name, platform)}`);
+            if (dep.required)
+                missing.push(dep.name);
+        }
+    }
+    results.push("\n## Proje Bağımlılıkları\n");
+    const pkgPath = path.join(resolved, "package.json");
+    try {
+        const pkgContent = await fs.readFile(pkgPath, "utf8");
+        const pkg = JSON.parse(pkgContent);
+        results.push(`Proje: ${pkg.name || "(isimsiz)"} v${pkg.version || "0.0.0"}`);
+        const requiredScripts = ["dev", "build"];
+        const scripts = pkg.scripts || {};
+        for (const s of requiredScripts) {
+            if (scripts[s]) {
+                results.push(`✓ scripts.${s}: ${scripts[s]}`);
+            }
+            else {
+                warnings.push(`scripts.${s} eksik`);
+                results.push(`✗ scripts.${s}: tanımlı değil`);
+            }
+        }
+        try {
+            await fs.access(path.join(resolved, "node_modules"));
+            results.push("✓ node_modules: mevcut");
+        }
+        catch {
+            missing.push("node_modules");
+            results.push("✗ node_modules: eksik → npm install çalıştır");
+        }
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        const keyDeps = ["next", "react", "typescript", "tailwindcss"];
+        for (const dep of keyDeps) {
+            if (allDeps[dep]) {
+                results.push(`✓ ${dep}: ${allDeps[dep]}`);
+            }
+        }
+    }
+    catch {
+        results.push("package.json bulunamadı — henüz proje oluşturulmamış olabilir");
+    }
+    results.push("\n## Özet\n");
+    if (missing.length === 0 && warnings.length === 0) {
+        results.push("✓ Tüm bağımlılıklar hazır — projeye başlanabilir.");
+    }
+    else {
+        if (missing.length > 0) {
+            results.push(`✗ Eksik (zorunlu): ${missing.join(", ")}`);
+        }
+        if (warnings.length > 0) {
+            results.push(`⚠ Uyarılar: ${warnings.join("; ")}`);
+        }
+    }
+    return {
+        success: missing.length === 0,
+        output: results.join("\n"),
+        metadata: {
+            platform,
+            arch: os.arch(),
+            missing,
+            warnings,
+            hasMissing: missing.length > 0,
+        },
+        duration: Date.now() - start,
+    };
+};

package/dist/tools/components.js

@@ -0,0 +1,76 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+const ALL_SHADCN_COMPONENTS = [
+    "accordion", "alert", "alert-dialog", "aspect-ratio", "avatar",
+    "badge", "breadcrumb", "button", "calendar", "card", "carousel",
+    "chart", "checkbox", "collapsible", "combobox", "command",
+    "context-menu", "data-table", "date-picker", "dialog", "drawer",
+    "dropdown-menu", "form", "hover-card", "input", "input-otp",
+    "label", "menubar", "navigation-menu", "pagination", "popover",
+    "progress", "radio-group", "resizable", "scroll-area", "select",
+    "separator", "sheet", "sidebar", "skeleton", "slider", "sonner",
+    "switch", "table", "tabs", "textarea", "toast", "toggle",
+    "toggle-group", "tooltip",
+];
+async function scanComponents(projectRoot) {
+    const componentsDir = path.join(projectRoot, "components", "ui");
+    const configPath = path.join(projectRoot, "components.json");
+    let hasConfig = false;
+    try {
+        await fs.access(configPath);
+        hasConfig = true;
+    }
+    catch {
+    }
+    const installed = [];
+    try {
+        const files = await fs.readdir(componentsDir);
+        for (const file of files) {
+            const name = file.replace(/\.(tsx|ts|jsx|js)$/, "");
+            if (name && !name.startsWith(".")) {
+                installed.push(name);
+            }
+        }
+    }
+    catch {
+    }
+    const installedSet = new Set(installed);
+    const available = ALL_SHADCN_COMPONENTS.filter((c) => !installedSet.has(c));
+    return { installed, available, hasConfig, componentsDir };
+}
+export const listComponentsHandler = async (params, ctx) => {
+    const start = Date.now();
+    const projectPath = (params.path || params.projectPath || ".");
+    const resolved = path.resolve(ctx.cwd, projectPath);
+    const result = await scanComponents(resolved);
+    const lines = [];
+    lines.push("## shadcn/ui Component Durumu\n");
+    if (!result.hasConfig) {
+        lines.push("⚠ components.json bulunamadı — shadcn/ui henüz init edilmemiş olabilir.");
+        lines.push("Kurulum: `npx --yes shadcn@latest init --yes --defaults`\n");
+    }
+    if (result.installed.length > 0) {
+        lines.push(`### Kurulu (${result.installed.length})`);
+        lines.push(result.installed.map((c) => `✓ ${c}`).join("\n"));
+        lines.push("");
+    }
+    else {
+        lines.push("### Kurulu: (yok)\n");
+    }
+    if (result.available.length > 0) {
+        lines.push(`### Kurulabilir (${result.available.length})`);
+        lines.push(result.available.map((c) => `  ${c}`).join("\n"));
+        lines.push("");
+        lines.push("Kurulum: `npx --yes shadcn@latest add <component> -y`");
+    }
+    return {
+        success: true,
+        output: lines.join("\n"),
+        metadata: {
+            installed: result.installed,
+            available: result.available,
+            hasConfig: result.hasConfig,
+        },
+        duration: Date.now() - start,
+    };
+};

package/dist/tools/docs-lookup.js

@@ -0,0 +1,125 @@
+import { log } from "../utils/logger.js";
+const DOCS_URLS = {
+    "next.js": "https://nextjs.org/docs",
+    nextjs: "https://nextjs.org/docs",
+    next: "https://nextjs.org/docs",
+    react: "https://react.dev/reference",
+    tailwind: "https://tailwindcss.com/docs",
+    tailwindcss: "https://tailwindcss.com/docs",
+    prisma: "https://www.prisma.io/docs",
+    shadcn: "https://ui.shadcn.com/docs",
+    "shadcn/ui": "https://ui.shadcn.com/docs",
+    typescript: "https://www.typescriptlang.org/docs/handbook",
+    ts: "https://www.typescriptlang.org/docs/handbook",
+    node: "https://nodejs.org/docs/latest/api",
+    nodejs: "https://nodejs.org/docs/latest/api",
+    vite: "https://vitejs.dev/guide",
+    zod: "https://zod.dev",
+    "framer-motion": "https://www.framer.com/motion",
+    framer: "https://www.framer.com/motion",
+    express: "https://expressjs.com/en/5x/api.html",
+    "ink": "https://github.com/vadimdemedes/ink",
+};
+export function listKnownFrameworks() {
+    return [...new Set(Object.values(DOCS_URLS))].map((url) => {
+        const match = Object.entries(DOCS_URLS).find(([, v]) => v === url);
+        return match?.[0] || url;
+    });
+}
+export function buildDocsUrl(framework, topic) {
+    const key = framework.toLowerCase().trim();
+    const base = DOCS_URLS[key];
+    if (!base)
+        return null;
+    if (!topic)
+        return base;
+    const slug = topic
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, "-")
+        .replace(/[^a-z0-9\-/]/g, "");
+    return `${base}/${slug}`;
+}
+function extractText(html) {
+    return html
+        .replace(/<script[\s\S]*?<\/script>/gi, "")
+        .replace(/<style[\s\S]*?<\/style>/gi, "")
+        .replace(/<nav[\s\S]*?<\/nav>/gi, "")
+        .replace(/<footer[\s\S]*?<\/footer>/gi, "")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&nbsp;/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+async function fetchDocsContent(url, maxChars = 15_000) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 15_000);
+    try {
+        const res = await fetch(url, {
+            headers: {
+                "User-Agent": "AIGENCY-CLI/1.0 (docs-lookup)",
+                Accept: "text/html,application/xhtml+xml",
+            },
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            return `HTTP ${res.status} — ${url} erişilemedi`;
+        }
+        const html = await res.text();
+        const text = extractText(html);
+        return text.slice(0, maxChars);
+    }
+    catch (err) {
+        if (err.name === "AbortError") {
+            return `Zaman aşımı — ${url} 15 saniyede yanıt vermedi`;
+        }
+        return `Hata: ${err.message.slice(0, 100)}`;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export const docsLookupHandler = async (params) => {
+    const start = Date.now();
+    const framework = String(params.framework || "").trim();
+    const topic = params.topic ? String(params.topic).trim() : undefined;
+    const directUrl = params.url ? String(params.url).trim() : undefined;
+    if (!framework && !directUrl) {
+        return {
+            success: false,
+            output: "",
+            error: "framework veya url parametresi gerekli",
+            duration: Date.now() - start,
+        };
+    }
+    let url;
+    if (directUrl) {
+        url = directUrl;
+    }
+    else {
+        const built = buildDocsUrl(framework, topic);
+        if (!built) {
+            const known = Object.keys(DOCS_URLS).slice(0, 10).join(", ");
+            return {
+                success: false,
+                output: "",
+                error: `'${framework}' için docs URL bulunamadı. Bilinenler: ${known}`,
+                duration: Date.now() - start,
+            };
+        }
+        url = built;
+    }
+    log.debug(`docs_lookup: ${url}`);
+    const content = await fetchDocsContent(url);
+    return {
+        success: true,
+        output: `## Dokümantasyon: ${framework || url}\nKaynak: ${url}\n\n${content}`,
+        metadata: { url, framework, topic },
+        duration: Date.now() - start,
+    };
+};