agcel 1.0.1

package/dist/commands/install.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installCommand = installCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const index_js_1 = require("../utils/index.js");
+async function installCommand() {
+    const globalDir = (0, index_js_1.getGlobalAgCelDir)();
+    const packageRoot = (0, index_js_1.getPackageRoot)();
+    console.log(chalk_1.default.blue('Installing AgCel globally...'));
+    try {
+        // 1. Create global directory
+        if (!fs_1.default.existsSync(globalDir)) {
+            console.log(chalk_1.default.blue(`Creating global directory at ${globalDir}...`));
+            fs_1.default.mkdirSync(globalDir, { recursive: true });
+        }
+        else {
+            console.log(chalk_1.default.yellow(`Global directory already exists at ${globalDir}. Updating...`));
+        }
+        // 2. Copy necessary files (dist, skills, workflows, package.json)
+        const dirsToCopy = [
+            { src: 'dist', dest: 'dist' },
+            { src: 'skills', dest: 'skills' },
+            { src: '.agent/workflows', dest: 'workflows' } // Normalize workflows path
+        ];
+        for (const dir of dirsToCopy) {
+            const srcPath = path_1.default.join(packageRoot, dir.src);
+            const destPath = path_1.default.join(globalDir, dir.dest);
+            if (fs_1.default.existsSync(srcPath)) {
+                console.log(chalk_1.default.blue(`Copying ${dir.src} to ${destPath}...`));
+                // Remove destination if it exists to ensure clean copy
+                if (fs_1.default.existsSync(destPath)) {
+                    fs_1.default.rmSync(destPath, { recursive: true, force: true });
+                }
+                fs_1.default.cpSync(srcPath, destPath, { recursive: true });
+            }
+            else {
+                console.warn(chalk_1.default.yellow(`Warning: Source directory ${srcPath} not found.`));
+            }
+        }
+        // Copy package.json for dependencies
+        const packageJsonSrc = path_1.default.join(packageRoot, 'package.json');
+        const packageJsonDest = path_1.default.join(globalDir, 'package.json');
+        if (fs_1.default.existsSync(packageJsonSrc)) {
+            fs_1.default.copyFileSync(packageJsonSrc, packageJsonDest);
+        }
+        // 3. Install dependencies in global dir
+        console.log(chalk_1.default.blue('Installing dependencies in global directory...'));
+        try {
+            (0, child_process_1.execSync)('npm install --production', { cwd: globalDir, stdio: 'inherit' });
+        }
+        catch (e) {
+            console.error(chalk_1.default.red('Failed to install dependencies.'), e);
+        }
+        // 4. Register with Antigravity
+        const mcpConfigPath = path_1.default.join(os_1.default.homedir(), '.gemini/antigravity/mcp_config.json');
+        let mcpConfig = { mcpServers: {} };
+        if (fs_1.default.existsSync(mcpConfigPath)) {
+            try {
+                const content = fs_1.default.readFileSync(mcpConfigPath, 'utf-8');
+                if (content.trim()) {
+                    mcpConfig = JSON.parse(content);
+                }
+            }
+            catch (e) {
+                console.warn(chalk_1.default.yellow('Existing MCP config invalid. Creating new.'));
+            }
+        }
+        else {
+            fs_1.default.mkdirSync(path_1.default.dirname(mcpConfigPath), { recursive: true });
+        }
+        if (!mcpConfig.mcpServers)
+            mcpConfig.mcpServers = {};
+        const serverPath = path_1.default.join(globalDir, 'dist/server/index.js');
+        mcpConfig.mcpServers['agcel'] = {
+            command: 'node',
+            args: [serverPath],
+            env: {
+                // Ensure the server knows where to find everything
+                NODE_ENV: 'production'
+            }
+        };
+        fs_1.default.writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+        console.log(chalk_1.default.green(`Successfully registered AgCel in ${mcpConfigPath}`));
+        console.log(chalk_1.default.green('AgCel installed successfully!'));
+        console.log(chalk_1.default.cyan('You can now run "agc init" in your projects to set them up.'));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Failed to install AgCel:'), error);
+        process.exit(1);
+    }
+}

package/dist/commands/list.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listCommand = listCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const index_js_1 = require("../utils/index.js");
+function listCommand(type) {
+    if (!(0, index_js_1.isInitialized)()) {
+        console.error(chalk_1.default.red('AgCel is not initialized. Run "agc init" first.'));
+        return;
+    }
+    const agCelDir = (0, index_js_1.getAgCelDir)();
+    // Check both source and local directories
+    // For now, let's assume we list what's in .agc
+    // Ideally, we should also check the global or project skills if integrated.
+    // NOTE: In a real implementation, we might want to list from the temp_skills directory too if configured?
+    // But per requirements, `agc init` creates .agc.
+    // Let's list from .AgCel/<type>
+    let targetDir = path_1.default.join(agCelDir, type);
+    // FIX: Workflows are stored in .agent/workflows, not .agc/workflows
+    if (type === 'workflows') {
+        targetDir = path_1.default.join(process.cwd(), '.agent', 'workflows');
+    }
+    if (!fs_1.default.existsSync(targetDir)) {
+        console.log(chalk_1.default.yellow(`No ${type} directory found in .agc.`));
+        return;
+    }
+    try {
+        const items = fs_1.default.readdirSync(targetDir).filter(item => {
+            return fs_1.default.statSync(path_1.default.join(targetDir, item)).isDirectory();
+        });
+        if (items.length === 0) {
+            console.log(chalk_1.default.yellow(`No ${type} found.`));
+        }
+        else {
+            console.log(chalk_1.default.blue(`Available ${type}:`));
+            items.forEach(item => {
+                console.log(`- ${item}`);
+            });
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Failed to list ${type}:`), error);
+    }
+}

package/dist/commands/restart.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restartCommand = restartCommand;
+const stop_js_1 = require("./stop.js");
+const start_js_1 = require("./start.js");
+const chalk_1 = __importDefault(require("chalk"));
+function restartCommand() {
+    console.log(chalk_1.default.blue('Restarting AgCel MCP server...'));
+    (0, stop_js_1.stopCommand)();
+    // Add a small delay to ensure the port is released
+    setTimeout(() => {
+        (0, start_js_1.startCommand)();
+    }, 1000);
+}

package/dist/commands/start.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startCommand = startCommand;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const chalk_1 = __importDefault(require("chalk"));
+const index_js_1 = require("../utils/index.js");
+function startCommand() {
+    if (!(0, index_js_1.isInitialized)()) {
+        console.error(chalk_1.default.red('AgCel is not initialized. Run "agc init" first.'));
+        return;
+    }
+    const existingPid = (0, index_js_1.getPid)();
+    if (existingPid && (0, index_js_1.isRunning)(existingPid)) {
+        console.log(chalk_1.default.yellow(`AgCel MCP server is already running (PID: ${existingPid})`));
+        return;
+    }
+    console.log(chalk_1.default.blue('Starting AgCel MCP server...'));
+    const serverScript = path_1.default.resolve(__dirname, '../../dist/server/index.js');
+    const logFile = path_1.default.join((0, index_js_1.getAgCelDir)(), 'server.log');
+    const out = fs_1.default.openSync(logFile, 'a');
+    const err = fs_1.default.openSync(logFile, 'a');
+    const child = (0, child_process_1.spawn)('node', [serverScript, '--mode', 'sse'], {
+        detached: true,
+        stdio: ['ignore', out, err],
+        cwd: process.cwd()
+    });
+    if (child.pid) {
+        (0, index_js_1.savePid)(child.pid);
+        child.unref();
+        console.log(chalk_1.default.green(`AgCel MCP server started successfully (PID: ${child.pid})`));
+        console.log(chalk_1.default.cyan(`Logs are being written to ${logFile}`));
+    }
+    else {
+        console.error(chalk_1.default.red('Failed to start AgCel MCP server.'));
+    }
+}

package/dist/commands/status.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusCommand = statusCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const index_js_1 = require("../utils/index.js");
+function statusCommand() {
+    if (!(0, index_js_1.isInitialized)()) {
+        console.log(chalk_1.default.red('AgCel is not initialized. Run "agc init" first.'));
+        return;
+    }
+    const pid = (0, index_js_1.getPid)();
+    if (pid && (0, index_js_1.isRunning)(pid)) {
+        console.log(chalk_1.default.green(`AgCel MCP server is running (PID: ${pid})`));
+    }
+    else {
+        console.log(chalk_1.default.yellow('AgCel MCP server is stopped'));
+        if (pid) {
+            console.log(chalk_1.default.yellow('(PID file exists but process is not running)'));
+        }
+    }
+}

package/dist/commands/stop.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopCommand = stopCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const index_js_1 = require("../utils/index.js");
+function stopCommand() {
+    const pid = (0, index_js_1.getPid)();
+    if (!pid) {
+        console.log(chalk_1.default.yellow('AgCel MCP server is not running (no PID file found).'));
+        return;
+    }
+    if (!(0, index_js_1.isRunning)(pid)) {
+        console.log(chalk_1.default.yellow(`AgCel MCP server is not running (PID ${pid} not found). Cleaning up PID file.`));
+        (0, index_js_1.removePid)();
+        return;
+    }
+    console.log(chalk_1.default.blue(`Stopping AgCel MCP server (PID: ${pid})...`));
+    try {
+        process.kill(pid);
+        (0, index_js_1.removePid)();
+        console.log(chalk_1.default.green('AgCel MCP server stopped successfully.'));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Failed to stop AgCel MCP server:'), error);
+    }
+}

package/dist/commands/uninstall.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uninstallCommand = uninstallCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const child_process_1 = require("child_process");
+const index_js_1 = require("../utils/index.js");
+async function uninstallCommand() {
+    const globalDir = (0, index_js_1.getGlobalAgCelDir)();
+    const mcpConfigPath = path_1.default.join(os_1.default.homedir(), '.gemini', 'antigravity', 'mcp_config.json');
+    console.log(chalk_1.default.blue('Uninstalling AgCel...'));
+    let requiresSudo = false;
+    // 1. Remove from MCP Config
+    if (fs_1.default.existsSync(mcpConfigPath)) {
+        try {
+            const content = fs_1.default.readFileSync(mcpConfigPath, 'utf-8');
+            const mcpConfig = JSON.parse(content);
+            if (mcpConfig.mcpServers && mcpConfig.mcpServers['agcel']) {
+                delete mcpConfig.mcpServers['agcel'];
+                fs_1.default.writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+                console.log(chalk_1.default.green(`Removed AgCel from ${mcpConfigPath}`));
+            }
+            else {
+                console.log(chalk_1.default.yellow('AgCel not found in MCP config.'));
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Failed to update MCP config:'), error);
+        }
+    }
+    else {
+        console.log(chalk_1.default.yellow('MCP config not found.'));
+    }
+    // 2. Remove Global Directory
+    if (fs_1.default.existsSync(globalDir)) {
+        try {
+            fs_1.default.rmSync(globalDir, { recursive: true, force: true });
+            console.log(chalk_1.default.green(`Removed global directory at ${globalDir}`));
+        }
+        catch (error) {
+            if (error.code === 'EACCES') {
+                console.error(chalk_1.default.red(`Permission denied removing ${globalDir}. You might need sudo.`));
+                requiresSudo = true;
+            }
+            else {
+                console.error(chalk_1.default.red(`Failed to remove global directory:`), error);
+            }
+        }
+    }
+    else {
+        console.log(chalk_1.default.yellow('Global directory not found.'));
+    }
+    // 3. Prompt for npm uninstall
+    const answer = await inquirer_1.default.prompt([{
+            type: 'confirm',
+            name: 'npmUninstall',
+            message: 'Do you want to run "npm uninstall -g agcel" now?',
+            default: true
+        }]);
+    if (answer.npmUninstall) {
+        try {
+            console.log(chalk_1.default.blue('Running "npm uninstall -g agcel"...'));
+            (0, child_process_1.execSync)('npm uninstall -g agcel', { stdio: 'inherit' });
+            console.log(chalk_1.default.green('AgCel package uninstalled successfully.'));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Failed to uninstall npm package.'));
+            console.error(chalk_1.default.yellow('You might need to run: sudo npm uninstall -g agcel'));
+        }
+    }
+    console.log(chalk_1.default.green('AgCel uninstallation complete.'));
+}

package/dist/index.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const init_js_1 = require("./commands/init.js");
+const install_js_1 = require("./commands/install.js");
+const uninstall_js_1 = require("./commands/uninstall.js");
+const start_js_1 = require("./commands/start.js");
+const stop_js_1 = require("./commands/stop.js");
+const restart_js_1 = require("./commands/restart.js");
+const status_js_1 = require("./commands/status.js");
+const list_js_1 = require("./commands/list.js");
+const program = new commander_1.Command();
+program
+    .name('agc')
+    .description('AgCel MCP Skills Server CLI')
+    .version('1.0.0');
+program
+    .command('init')
+    .description('Initialize AgCel in the current directory')
+    .action(init_js_1.initCommand);
+program
+    .command('install')
+    .description('Install AgCel globally')
+    .action(install_js_1.installCommand);
+program
+    .command('uninstall')
+    .description('Uninstall AgCel globally')
+    .action(uninstall_js_1.uninstallCommand);
+program
+    .command('start')
+    .description('Start the MCP server locally')
+    .action(start_js_1.startCommand);
+program
+    .command('stop')
+    .description('Stop the MCP server locally')
+    .action(stop_js_1.stopCommand);
+program
+    .command('restart')
+    .description('Restart the MCP server locally')
+    .action(restart_js_1.restartCommand);
+program
+    .command('status')
+    .description('Check the status of the MCP server')
+    .action(status_js_1.statusCommand);
+const skillskCommand = new commander_1.Command('skills');
+skillskCommand
+    .command('list')
+    .description('List available skills')
+    .action(() => (0, list_js_1.listCommand)('skills'));
+const workflowsCommand = new commander_1.Command('workflows');
+workflowsCommand
+    .command('list')
+    .description('List available workflows')
+    .action(() => (0, list_js_1.listCommand)('workflows'));
+program.addCommand(skillskCommand);
+program.addCommand(workflowsCommand);
+program.parse(process.argv);

package/dist/server/index.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const index_js_2 = require("../utils/index.js");
+// Argument parsing for transport mode
+const args = process.argv.slice(2);
+const modeIndex = args.indexOf('--mode');
+const mode = modeIndex !== -1 ? args[modeIndex + 1] : 'stdio'; // Default to stdio if not specified
+const server = new index_js_1.Server({
+    name: "AgCel",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+        resources: {}
+    },
+});
+// Helper to load skills
+// Helper to determine the skills directory
+function getSkillsDir() {
+    const agCelDir = (0, index_js_2.getAgCelDir)();
+    let skillsDir = path_1.default.join(agCelDir, 'skills');
+    // Fallback for global install where skills are in project root (e.g. ~/.agc/skills)
+    if (!fs_1.default.existsSync(skillsDir)) {
+        skillsDir = path_1.default.join(process.cwd(), 'skills');
+    }
+    // Double fallback to global installation directory
+    if (!fs_1.default.existsSync(skillsDir)) {
+        skillsDir = path_1.default.join((0, index_js_2.getGlobalAgCelDir)(), 'skills');
+    }
+    if (!fs_1.default.existsSync(skillsDir))
+        return null;
+    return skillsDir;
+}
+// Helper to load skills
+function getSkills() {
+    const skillsDir = getSkillsDir();
+    if (!skillsDir)
+        return [];
+    return fs_1.default.readdirSync(skillsDir).filter(skill => {
+        return fs_1.default.statSync(path_1.default.join(skillsDir, skill)).isDirectory() && fs_1.default.existsSync(path_1.default.join(skillsDir, skill, 'SKILL.md'));
+    });
+}
+// List Tools Handler
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+    const skills = getSkills();
+    const tools = skills.map(skill => {
+        return {
+            name: skill,
+            description: `Retrieve instructions for the ${skill} skill`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    instruction: {
+                        type: "string",
+                        description: "Context or specific requirements for retrieving the skill"
+                    }
+                },
+                required: ["instruction"]
+            }
+        };
+    });
+    return {
+        tools: tools
+    };
+});
+// Call Tool Handler
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const skills = getSkills();
+    const skillsDir = getSkillsDir();
+    if (skillsDir && skills.includes(name)) {
+        const skillPath = path_1.default.join(skillsDir, name, 'SKILL.md');
+        if (fs_1.default.existsSync(skillPath)) {
+            const content = fs_1.default.readFileSync(skillPath, 'utf-8');
+            const ironRule = `
+## Iron Rules
+1. If there is anything unclear, ask the user instead of inventing new stuff. Unless the user explicitly tells the AI to invent or suggest ideas.
+`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: content + ironRule
+                    }
+                ]
+            };
+        }
+    }
+    throw new Error(`Tool not found: ${name}`);
+});
+// List Resources Handler
+server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
+    const skills = getSkills();
+    const resources = skills.map(skill => ({
+        uri: `agcel://skills/${skill}/SKILL.md`,
+        name: `${skill} Documentation`,
+        mimeType: "text/markdown"
+    }));
+    return { resources };
+});
+// Read Resource Handler
+server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    const match = uri.match(/^agcel:\/\/skills\/([^\/]+)\/SKILL.md$/);
+    if (match) {
+        const skill = match[1];
+        const skillsDir = getSkillsDir();
+        if (skillsDir) {
+            const skillPath = path_1.default.join(skillsDir, skill, 'SKILL.md');
+            if (fs_1.default.existsSync(skillPath)) {
+                const content = fs_1.default.readFileSync(skillPath, 'utf-8');
+                return {
+                    contents: [{ uri, mimeType: "text/markdown", text: content }]
+                };
+            }
+        }
+    }
+    throw new Error(`Resource not found: ${uri}`);
+});
+async function main() {
+    if (mode === 'sse') {
+        const app = (0, express_1.default)();
+        app.use((0, cors_1.default)());
+        const agCelDir = (0, index_js_2.getAgCelDir)();
+        const configPath = path_1.default.join(agCelDir, 'config.json');
+        let port = 3000;
+        if (fs_1.default.existsSync(configPath)) {
+            try {
+                const config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
+                if (config.port)
+                    port = config.port;
+            }
+            catch (e) {
+                console.error("Failed to read config:", e);
+            }
+        }
+        let transport;
+        app.get('/sse', async (req, res) => {
+            transport = new sse_js_1.SSEServerTransport('/message', res);
+            await server.connect(transport);
+        });
+        app.post('/message', async (req, res) => {
+            if (transport) {
+                await transport.handlePostMessage(req, res);
+            }
+            else {
+                res.status(404).json({ error: "Session not found" });
+            }
+        });
+        app.listen(port, () => {
+            console.log(`AgCel MCP Server running on SSE at http://localhost:${port}/sse`);
+        });
+    }
+    else {
+        const transport = new stdio_js_1.StdioServerTransport();
+        await server.connect(transport);
+        console.error("AgCel MCP Server running on stdio");
+    }
+}
+main().catch((error) => {
+    console.error("Server error:", error);
+    process.exit(1);
+});

package/dist/utils/index.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AG_CEL_PID_FILE = exports.AG_CEL_CONFIG_FILE = exports.AG_CEL_DIR = void 0;
+exports.getPackageRoot = getPackageRoot;
+exports.getAgCelDir = getAgCelDir;
+exports.getGlobalAgCelDir = getGlobalAgCelDir;
+exports.isInitialized = isInitialized;
+exports.getPidFile = getPidFile;
+exports.savePid = savePid;
+exports.getPid = getPid;
+exports.removePid = removePid;
+exports.isRunning = isRunning;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+// In CJS, __dirname is available globally
+function getPackageRoot() {
+    return path_1.default.resolve(__dirname, '..', '..');
+}
+exports.AG_CEL_DIR = '.agc';
+exports.AG_CEL_CONFIG_FILE = 'config.json';
+exports.AG_CEL_PID_FILE = 'mcp-server.pid';
+function getAgCelDir() {
+    return path_1.default.join(process.cwd(), exports.AG_CEL_DIR);
+}
+function getGlobalAgCelDir() {
+    return path_1.default.join(os_1.default.homedir(), '.agcel');
+}
+function isInitialized() {
+    return fs_1.default.existsSync(getAgCelDir());
+}
+function getPidFile() {
+    return path_1.default.join(getAgCelDir(), exports.AG_CEL_PID_FILE);
+}
+function savePid(pid) {
+    fs_1.default.writeFileSync(getPidFile(), pid.toString());
+}
+function getPid() {
+    const pidFile = getPidFile();
+    if (fs_1.default.existsSync(pidFile)) {
+        const pid = parseInt(fs_1.default.readFileSync(pidFile, 'utf-8'), 10);
+        return pid;
+    }
+    return null;
+}
+function removePid() {
+    const pidFile = getPidFile();
+    if (fs_1.default.existsSync(pidFile)) {
+        fs_1.default.unlinkSync(pidFile);
+    }
+}
+function isRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}