@infinitedusky/indusk-mcp 0.9.1 → 1.0.1

package/dist/bin/cli.js

@@ -14,15 +14,11 @@ program
     .command("init")
     .description("Initialize a project with InDusk dev system")
     .option("-f, --force", "Overwrite existing files (except CLAUDE.md and planning/)")
-    .option("--skills <list>", "Comma-separated domain skills to install (e.g., nextjs,tailwind)")
-    .option("--no-domain-skills", "Skip domain skill detection and installation")
     .option("--no-index", "Skip code graph indexing")
     .action(async (opts) => {
     const { init } = await import("./commands/init.js");
     await init(process.cwd(), {
         force: opts.force ?? false,
-        skills: opts.skills,
-        noDomainSkills: opts.domainSkills === false,
         noIndex: opts.index === false,
     });
 });
@@ -33,6 +29,59 @@ program
     const { update } = await import("./commands/update.js");
     await update(process.cwd());
 });
+const ext = program
+    .command("extensions")
+    .description("Manage extensions (built-in and third-party)");
+ext
+    .command("list")
+    .description("Show all available extensions")
+    .action(async () => {
+    const { extensionsList } = await import("./commands/extensions.js");
+    await extensionsList(process.cwd());
+});
+ext
+    .command("status")
+    .description("Show enabled extensions with health")
+    .action(async () => {
+    const { extensionsStatus } = await import("./commands/extensions.js");
+    await extensionsStatus(process.cwd());
+});
+ext
+    .command("enable <names...>")
+    .description("Enable extensions")
+    .action(async (names) => {
+    const { extensionsEnable } = await import("./commands/extensions.js");
+    await extensionsEnable(process.cwd(), names);
+});
+ext
+    .command("disable <names...>")
+    .description("Disable extensions")
+    .action(async (names) => {
+    const { extensionsDisable } = await import("./commands/extensions.js");
+    await extensionsDisable(process.cwd(), names);
+});
+ext
+    .command("add <name>")
+    .description("Add a third-party extension")
+    .requiredOption("--from <source>", "Source: npm:pkg, github:user/repo, URL, or local path")
+    .action(async (name, opts) => {
+    const { extensionsAdd } = await import("./commands/extensions.js");
+    await extensionsAdd(process.cwd(), name, opts.from);
+});
+ext
+    .command("remove <names...>")
+    .description("Remove extensions")
+    .action(async (names) => {
+    const { extensionsRemove } = await import("./commands/extensions.js");
+    await extensionsRemove(process.cwd(), names);
+});
+ext
+    .command("suggest")
+    .description("Recommend extensions based on project contents")
+    .action(async () => {
+    const { extensionsSuggest } = await import("./commands/extensions.js");
+    await extensionsSuggest(process.cwd());
+});
 program
     .command("init-docs")
     .description("Scaffold a VitePress documentation site with Mermaid, llms.txt, and FullscreenDiagram")

package/dist/bin/commands/extensions.d.ts

@@ -0,0 +1,7 @@
+export declare function extensionsList(projectRoot: string): Promise<void>;
+export declare function extensionsStatus(projectRoot: string): Promise<void>;
+export declare function extensionsEnable(projectRoot: string, names: string[]): Promise<void>;
+export declare function extensionsDisable(projectRoot: string, names: string[]): Promise<void>;
+export declare function extensionsAdd(projectRoot: string, name: string, from: string): Promise<void>;
+export declare function extensionsRemove(projectRoot: string, names: string[]): Promise<void>;
+export declare function extensionsSuggest(projectRoot: string): Promise<void>;

package/dist/bin/commands/extensions.js

@@ -0,0 +1,288 @@
+import { execSync } from "node:child_process";
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { globSync } from "glob";
+import { disableExtension, enableExtension, ensureExtensionsDirs, extensionsDir, getEnabledExtensions, isEnabled, loadExtension, loadExtensions, } from "../../lib/extension-loader.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageRoot = join(__dirname, "../../..");
+const builtinDir = join(packageRoot, "extensions");
+function getBuiltinExtensions() {
+    if (!existsSync(builtinDir))
+        return [];
+    const dirs = globSync("*/manifest.json", { cwd: builtinDir });
+    return dirs
+        .map((d) => loadExtension(join(builtinDir, d)))
+        .filter((m) => m !== null);
+}
+export async function extensionsList(projectRoot) {
+    const builtins = getBuiltinExtensions();
+    const installed = loadExtensions(projectRoot);
+    console.info("Built-in extensions:\n");
+    for (const ext of builtins) {
+        const status = isEnabled(projectRoot, ext.name)
+            ? "enabled"
+            : installed.some((i) => i.manifest.name === ext.name)
+                ? "disabled"
+                : "not installed";
+        console.info(`  ${ext.name} — ${ext.description} [${status}]`);
+    }
+    const thirdParty = installed.filter((i) => !builtins.some((b) => b.name === i.manifest.name));
+    if (thirdParty.length > 0) {
+        console.info("\nThird-party extensions:\n");
+        for (const ext of thirdParty) {
+            const status = ext.enabled ? "enabled" : "disabled";
+            console.info(`  ${ext.manifest.name} — ${ext.manifest.description} [${status}]`);
+        }
+    }
+}
+export async function extensionsStatus(projectRoot) {
+    const enabled = getEnabledExtensions(projectRoot);
+    if (enabled.length === 0) {
+        console.info("No extensions enabled. Run `extensions list` to see available.");
+        return;
+    }
+    console.info("Enabled extensions:\n");
+    for (const ext of enabled) {
+        const checks = ext.manifest.provides.health_checks ?? [];
+        let healthStatus = "no health check";
+        if (checks.length > 0) {
+            const results = checks.map((check) => {
+                try {
+                    execSync(check.command, {
+                        cwd: projectRoot,
+                        timeout: 10000,
+                        stdio: ["ignore", "pipe", "pipe"],
+                    });
+                    return { name: check.name, ok: true };
+                }
+                catch {
+                    return { name: check.name, ok: false };
+                }
+            });
+            const allOk = results.every((r) => r.ok);
+            healthStatus = allOk
+                ? "healthy"
+                : `unhealthy: ${results
+                    .filter((r) => !r.ok)
+                    .map((r) => r.name)
+                    .join(", ")}`;
+        }
+        console.info(`  ${ext.manifest.name} — ${healthStatus}`);
+    }
+}
+export async function extensionsEnable(projectRoot, names) {
+    ensureExtensionsDirs(projectRoot);
+    for (const name of names) {
+        // Check if already enabled
+        if (isEnabled(projectRoot, name)) {
+            console.info(`  ${name}: already enabled`);
+            continue;
+        }
+        // Try to move from disabled
+        if (enableExtension(projectRoot, name)) {
+            console.info(`  ${name}: enabled (was disabled)`);
+            runHook(projectRoot, name, "on_init");
+            installSkill(projectRoot, name);
+            continue;
+        }
+        // Try to copy from built-in
+        const builtinManifest = join(builtinDir, name, "manifest.json");
+        if (existsSync(builtinManifest)) {
+            const targetPath = join(extensionsDir(projectRoot), `${name}.json`);
+            cpSync(builtinManifest, targetPath);
+            console.info(`  ${name}: enabled (built-in)`);
+            runHook(projectRoot, name, "on_init");
+            installSkill(projectRoot, name);
+            continue;
+        }
+        console.info(`  ${name}: not found — use 'extensions add ${name} --from <source>' for third-party`);
+    }
+}
+export async function extensionsDisable(projectRoot, names) {
+    for (const name of names) {
+        if (disableExtension(projectRoot, name)) {
+            console.info(`  ${name}: disabled`);
+        }
+        else {
+            console.info(`  ${name}: not found or already disabled`);
+        }
+    }
+}
+export async function extensionsAdd(projectRoot, name, from) {
+    ensureExtensionsDirs(projectRoot);
+    let manifestContent = null;
+    if (from.startsWith("npm:")) {
+        // Fetch from npm package
+        const pkg = from.slice(4);
+        try {
+            const result = execSync(`npm pack ${pkg} --dry-run --json 2>/dev/null || echo "[]"`, {
+                encoding: "utf-8",
+                timeout: 30000,
+            });
+            // Try to read the manifest from the installed package
+            const npmRoot = execSync(`npm root`, { encoding: "utf-8", cwd: projectRoot }).trim();
+            const manifestPath = join(npmRoot, pkg, "indusk-extension.json");
+            if (existsSync(manifestPath)) {
+                manifestContent = readFileSync(manifestPath, "utf-8");
+            }
+            else {
+                console.info(`  ${name}: no indusk-extension.json found in ${pkg}`);
+                return;
+            }
+        }
+        catch {
+            console.info(`  ${name}: failed to fetch from npm:${pkg}`);
+            return;
+        }
+    }
+    else if (from.startsWith("github:")) {
+        // Fetch from GitHub raw
+        const repo = from.slice(7);
+        const url = `https://raw.githubusercontent.com/${repo}/main/indusk-extension.json`;
+        try {
+            const result = execSync(`curl -sf "${url}"`, { encoding: "utf-8", timeout: 15000 });
+            manifestContent = result;
+        }
+        catch {
+            console.info(`  ${name}: failed to fetch from ${url}`);
+            return;
+        }
+    }
+    else if (from.startsWith("http://") || from.startsWith("https://")) {
+        try {
+            manifestContent = execSync(`curl -sf "${from}"`, { encoding: "utf-8", timeout: 15000 });
+        }
+        catch {
+            console.info(`  ${name}: failed to fetch from ${from}`);
+            return;
+        }
+    }
+    else {
+        // Local path
+        if (existsSync(from)) {
+            manifestContent = readFileSync(from, "utf-8");
+        }
+        else {
+            console.info(`  ${name}: file not found at ${from}`);
+            return;
+        }
+    }
+    if (!manifestContent)
+        return;
+    // Validate
+    try {
+        const manifest = JSON.parse(manifestContent);
+        if (!manifest.name || !manifest.provides) {
+            console.info(`  ${name}: invalid manifest (missing name or provides)`);
+            return;
+        }
+    }
+    catch {
+        console.info(`  ${name}: invalid JSON in manifest`);
+        return;
+    }
+    const targetPath = join(extensionsDir(projectRoot), `${name}.json`);
+    writeFileSync(targetPath, manifestContent);
+    console.info(`  ${name}: added from ${from}`);
+}
+export async function extensionsRemove(projectRoot, names) {
+    for (const name of names) {
+        const enPath = join(extensionsDir(projectRoot), `${name}.json`);
+        const disPath = join(extensionsDir(projectRoot), ".disabled", `${name}.json`);
+        if (existsSync(enPath)) {
+            rmSync(enPath);
+            console.info(`  ${name}: removed`);
+        }
+        else if (existsSync(disPath)) {
+            rmSync(disPath);
+            console.info(`  ${name}: removed (was disabled)`);
+        }
+        else {
+            console.info(`  ${name}: not found`);
+        }
+        // Remove skill if installed
+        const skillDir = join(projectRoot, ".claude/skills", name);
+        if (existsSync(skillDir)) {
+            rmSync(skillDir, { recursive: true });
+            console.info(`  ${name}: skill removed from .claude/skills/`);
+        }
+    }
+}
+export async function extensionsSuggest(projectRoot) {
+    const builtins = getBuiltinExtensions();
+    const suggestions = [];
+    for (const ext of builtins) {
+        if (isEnabled(projectRoot, ext.name))
+            continue;
+        if (!ext.detect)
+            continue;
+        if (ext.detect.file && existsSync(join(projectRoot, ext.detect.file))) {
+            suggestions.push({ name: ext.name, reason: `${ext.detect.file} found` });
+            continue;
+        }
+        if (ext.detect.file_pattern) {
+            const matches = globSync(ext.detect.file_pattern, { cwd: projectRoot, maxDepth: 3 });
+            if (matches.length > 0) {
+                suggestions.push({ name: ext.name, reason: `${ext.detect.file_pattern} found` });
+                continue;
+            }
+        }
+        if (ext.detect.dependency || ext.detect.devDependency) {
+            const pkgPath = join(projectRoot, "package.json");
+            if (existsSync(pkgPath)) {
+                const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+                const deps = pkg.dependencies ?? {};
+                const devDeps = pkg.devDependencies ?? {};
+                if (ext.detect.dependency && deps[ext.detect.dependency]) {
+                    suggestions.push({ name: ext.name, reason: `${ext.detect.dependency} in dependencies` });
+                }
+                else if (ext.detect.devDependency && devDeps[ext.detect.devDependency]) {
+                    suggestions.push({
+                        name: ext.name,
+                        reason: `${ext.detect.devDependency} in devDependencies`,
+                    });
+                }
+            }
+        }
+    }
+    if (suggestions.length === 0) {
+        console.info("No extension suggestions — all detected extensions are already enabled.");
+        return;
+    }
+    console.info("Suggested extensions:\n");
+    for (const s of suggestions) {
+        console.info(`  ${s.name} — ${s.reason}`);
+    }
+    console.info(`\nEnable with: extensions enable ${suggestions.map((s) => s.name).join(" ")}`);
+}
+// --- Helpers ---
+function runHook(projectRoot, name, hook) {
+    const extPath = join(extensionsDir(projectRoot), `${name}.json`);
+    const manifest = loadExtension(extPath);
+    if (!manifest?.hooks)
+        return;
+    const command = manifest.hooks[hook];
+    if (!command)
+        return;
+    try {
+        execSync(command, { cwd: projectRoot, stdio: "inherit", timeout: 30000 });
+    }
+    catch {
+        console.info(`  ${name}: ${hook} hook failed`);
+    }
+}
+function installSkill(projectRoot, name) {
+    const extPath = join(extensionsDir(projectRoot), `${name}.json`);
+    const manifest = loadExtension(extPath);
+    if (!manifest?.provides.skill)
+        return;
+    // Look for skill.md in built-in extensions
+    const builtinSkill = join(builtinDir, name, "skill.md");
+    if (existsSync(builtinSkill)) {
+        const targetDir = join(projectRoot, ".claude/skills", name);
+        mkdirSync(targetDir, { recursive: true });
+        cpSync(builtinSkill, join(targetDir, "SKILL.md"));
+        console.info(`  ${name}: skill installed to .claude/skills/${name}/SKILL.md`);
+    }
+}

package/dist/bin/commands/init.d.ts

@@ -1,7 +1,5 @@
 export interface InitOptions {
     force?: boolean;
-    skills?: string;
-    noDomainSkills?: boolean;
     noIndex?: boolean;
 }
 export declare function init(projectRoot: string, options?: InitOptions): Promise<void>;

package/dist/bin/commands/init.js

@@ -17,34 +17,6 @@ function run(cmd, options) {
         return "";
     }
 }
-function ensureFalkorDB() {
-    // Check if FalkorDB container exists and is running
-    const status = run('docker ps --filter name=falkordb --format "{{.Status}}"');
-    if (status) {
-        console.info("  ok: FalkorDB container running");
-        return;
-    }
-    // Check if container exists but is stopped
-    const stopped = run('docker ps -a --filter name=falkordb --format "{{.Status}}"');
-    if (stopped) {
-        console.info("  start: FalkorDB container (was stopped)");
-        run("docker start falkordb");
-        return;
-    }
-    // Create and start the container
-    console.info("  create: FalkorDB container (global, persistent)");
-    run("docker run -d --name falkordb --restart unless-stopped -p 6379:6379 -v falkordb-global:/data falkordb/falkordb:latest");
-}
-function checkCGC() {
-    const cgcPaths = [join(process.env.HOME ?? "", ".local/bin/cgc"), "/usr/local/bin/cgc"];
-    const found = cgcPaths.find((p) => existsSync(p));
-    if (found) {
-        console.info(`  ok: CGC found at ${found}`);
-        return true;
-    }
-    console.info("  missing: CGC — install via: pipx install codegraphcontext");
-    return false;
-}
 function createCgcIgnore(projectRoot) {
     const ignorePath = join(projectRoot, ".cgcignore");
     if (existsSync(ignorePath)) {
@@ -70,56 +42,8 @@ function createCgcIgnore(projectRoot) {
     ].join("\n"));
     console.info("  create: .cgcignore");
 }
-const DOMAIN_DETECTION_MAP = [
-    { signal: "dependency", match: "next", skill: "nextjs" },
-    { signal: "dependency", match: "tailwindcss", skill: "tailwind" },
-    { signal: "dependency", match: "react", skill: "react" },
-    { signal: "devDependency", match: "typescript", skill: "typescript" },
-    { signal: "devDependency", match: "vitest", skill: "testing" },
-    { signal: "devDependency", match: "jest", skill: "testing" },
-    { signal: "dependency", match: "vitepress", skill: "vitepress" },
-];
-const FILE_PATTERN_DETECTIONS = [
-    { pattern: "*.sol", skill: "solidity" },
-    { pattern: "Dockerfile*", skill: "docker" },
-];
-function detectDomainSkills(projectRoot) {
-    const detections = [];
-    const seen = new Set();
-    // Check package.json dependencies
-    const pkgPath = join(projectRoot, "package.json");
-    if (existsSync(pkgPath)) {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        const deps = pkg.dependencies ?? {};
-        const devDeps = pkg.devDependencies ?? {};
-        for (const rule of DOMAIN_DETECTION_MAP) {
-            if (seen.has(rule.skill))
-                continue;
-            const source = rule.signal === "dependency" ? deps : devDeps;
-            if (source[rule.match]) {
-                detections.push({
-                    skill: rule.skill,
-                    signal: rule.signal,
-                    match: rule.match,
-                });
-                seen.add(rule.skill);
-            }
-        }
-    }
-    // Check file patterns
-    for (const rule of FILE_PATTERN_DETECTIONS) {
-        if (seen.has(rule.skill))
-            continue;
-        const matches = globSync(rule.pattern, { cwd: projectRoot, maxDepth: 3 });
-        if (matches.length > 0) {
-            detections.push({ skill: rule.skill, signal: "file-pattern", match: rule.pattern });
-            seen.add(rule.skill);
-        }
-    }
-    return detections;
-}
 export async function init(projectRoot, options = {}) {
-    const { force = false, skills, noDomainSkills = false, noIndex = false } = options;
+    const { force = false, noIndex = false } = options;
     const projectName = basename(projectRoot);
     console.info(`Initializing InDusk dev system...${force ? " (--force)" : ""}\n`);
     // 1. Copy skills
@@ -139,49 +63,7 @@ export async function init(projectRoot, options = {}) {
         cpSync(join(skillsSource, file), targetFile);
         console.info(`  ${existsSync(targetFile) ? "overwrite" : "create"}: .claude/skills/${skillName}/SKILL.md`);
     }
-    // 2. Install domain skills
-    if (!noDomainSkills) {
-        console.info("\n[Domain Skills]");
-        const domainSource = join(packageRoot, "skills/domain");
-        let skillsToInstall;
-        if (skills) {
-            skillsToInstall = skills.split(",").map((s) => s.trim());
-            console.info(`  manual: installing ${skillsToInstall.join(", ")}`);
-        }
-        else {
-            const detections = detectDomainSkills(projectRoot);
-            skillsToInstall = detections.map((d) => d.skill);
-            if (detections.length > 0) {
-                for (const d of detections) {
-                    console.info(`  detected: ${d.skill} (${d.signal}: ${d.match})`);
-                }
-            }
-            else {
-                console.info("  none detected");
-            }
-        }
-        for (const skillName of skillsToInstall) {
-            const sourceFile = join(domainSource, `${skillName}.md`);
-            if (!existsSync(sourceFile)) {
-                console.info(`  skip: ${skillName} (not found in registry)`);
-                continue;
-            }
-            const targetDir = join(skillsTarget, skillName);
-            const targetFile = join(targetDir, "SKILL.md");
-            if (existsSync(targetFile) && !force) {
-                console.info(`  skip: .claude/skills/${skillName}/SKILL.md (already exists)`);
-                continue;
-            }
-            mkdirSync(targetDir, { recursive: true });
-            cpSync(sourceFile, targetFile);
-            console.info(`  install: .claude/skills/${skillName}/SKILL.md`);
-        }
-    }
-    else {
-        console.info("\n[Domain Skills]");
-        console.info("  skipped (--no-domain-skills)");
-    }
-    // 3. Copy community lessons
+    // 2. Copy community lessons
     console.info("\n[Lessons]");
     const lessonsSource = join(packageRoot, "lessons/community");
     const lessonsTarget = join(projectRoot, ".claude/lessons");
@@ -232,8 +114,7 @@ export async function init(projectRoot, options = {}) {
         args: ["mcp", "start"],
         env: {
             DATABASE_TYPE: "falkordb-remote",
-            FALKORDB_HOST: "localhost",
-            FALKORDB_PORT: "6379",
+            FALKORDB_HOST: "falkordb.orb.local",
             FALKORDB_GRAPH_NAME: projectName,
         },
     };
@@ -367,47 +248,54 @@ export async function init(projectRoot, options = {}) {
     }
     // 8. Create .cgcignore (always overwrite — package-owned)
     createCgcIgnore(projectRoot);
-    // 8. Infrastructure: FalkorDB + CGC
-    console.info("\n[Infrastructure]");
-    const dockerAvailable = run("docker info") !== "";
-    if (dockerAvailable) {
-        ensureFalkorDB();
+    // 9. Run on_init hooks from enabled extensions
+    console.info("\n[Extension Hooks]");
+    const { getEnabledExtensions } = await import("../../lib/extension-loader.js");
+    const enabledExts = getEnabledExtensions(projectRoot);
+    for (const ext of enabledExts) {
+        if (ext.manifest.hooks?.on_init) {
+            console.info(`  ${ext.manifest.name}: running on_init...`);
+            const result = run(ext.manifest.hooks.on_init);
+            if (result) {
+                console.info(`  ${ext.manifest.name}: ${result.slice(0, 100)}`);
+            }
+        }
     }
-    else {
-        console.info("  missing: Docker — install Docker or OrbStack to enable FalkorDB");
+    if (enabledExts.length === 0) {
+        console.info("  no extensions enabled — run 'extensions enable' to add tool integrations");
     }
-    const cgcInstalled = checkCGC();
-    // 9. Auto-index the codebase into the graph
+    // 10. Auto-index the codebase into the graph (if CGC extension is enabled)
+    const cgcEnabled = enabledExts.some((e) => e.manifest.name === "cgc");
     if (noIndex) {
         console.info("\n[Code Graph]");
         console.info("  skipped (--no-index)");
     }
-    else if (dockerAvailable && cgcInstalled) {
+    else if (cgcEnabled) {
         console.info("\n[Code Graph]");
         console.info("  indexing: scanning codebase...");
-        const { indexProject } = await import("../../tools/graph-tools.js");
-        const result = indexProject(projectRoot);
-        if (result.success) {
-            console.info(`  done: ${result.output}`);
+        try {
+            const { indexProject } = await import("../../tools/graph-tools.js");
+            const result = indexProject(projectRoot);
+            if (result.success) {
+                console.info(`  done: ${result.output}`);
+            }
+            else {
+                console.info(`  error: ${result.output}`);
+            }
         }
-        else {
-            console.info(`  error: ${result.output}`);
+        catch {
+            console.info("  skipped (CGC not available)");
         }
     }
+    // 11. Suggest extensions
+    console.info("\n[Extensions]");
+    const { extensionsSuggest } = await import("./extensions.js");
+    await extensionsSuggest(projectRoot);
     // Summary
     console.info("\nDone!");
-    if (!cgcInstalled || !dockerAvailable) {
-        console.info("\nManual steps needed:");
-        if (!dockerAvailable) {
-            console.info("  1. Install Docker or OrbStack");
-            console.info("  2. Re-run init to set up FalkorDB");
-        }
-        if (!cgcInstalled) {
-            console.info("  - Install CGC: pipx install codegraphcontext");
-        }
-    }
     console.info("\nNext steps:");
     console.info("  1. Edit CLAUDE.md with your project details");
-    console.info("  2. Start a Claude Code session — MCP tools will be available");
-    console.info("  3. Start planning: /plan your-first-feature");
+    console.info("  2. Enable extensions: extensions enable falkordb cgc typescript");
+    console.info("  3. Start a Claude Code session — MCP tools will be available");
+    console.info("  4. Start planning: /plan your-first-feature");
 }

package/dist/lib/extension-loader.d.ts

@@ -0,0 +1,60 @@
+export interface DetectRule {
+    file?: string;
+    file_pattern?: string;
+    dependency?: string;
+    devDependency?: string;
+}
+export interface HealthCheck {
+    name: string;
+    command: string;
+}
+export interface VerificationEntry {
+    name: string;
+    command: string;
+    detect?: DetectRule;
+}
+export interface ExtensionManifest {
+    name: string;
+    description: string;
+    version?: string;
+    provides: {
+        skill?: boolean;
+        networking?: {
+            env_file?: string;
+            command?: string;
+            description?: string;
+        };
+        services?: {
+            command?: string;
+            description?: string;
+        };
+        health_checks?: HealthCheck[];
+        verification?: VerificationEntry[];
+        env_vars?: Record<string, string> | {
+            source: string;
+            files?: string[];
+        };
+    };
+    hooks?: {
+        on_init?: string;
+        on_update?: string;
+        on_health_check?: string;
+        on_onboard?: string;
+    };
+    detect?: DetectRule;
+}
+export interface LoadedExtension {
+    manifest: ExtensionManifest;
+    path: string;
+    enabled: boolean;
+}
+export declare function extensionsDir(projectRoot: string): string;
+export declare function disabledDir(projectRoot: string): string;
+export declare function ensureExtensionsDirs(projectRoot: string): void;
+export declare function loadExtension(manifestPath: string): ExtensionManifest | null;
+export declare function loadExtensions(projectRoot: string): LoadedExtension[];
+export declare function getEnabledExtensions(projectRoot: string): LoadedExtension[];
+export declare function enableExtension(projectRoot: string, name: string): boolean;
+export declare function disableExtension(projectRoot: string, name: string): boolean;
+export declare function isEnabled(projectRoot: string, name: string): boolean;
+export declare function getExtension(projectRoot: string, name: string): LoadedExtension | null;