@aman_asmuei/akit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aman Asmuei
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,165 @@
+<div align="center">
+
+<br>
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/badge/akit-capability_layer-white?style=for-the-badge&labelColor=0d1117&color=58a6ff">
+  <img alt="akit" src="https://img.shields.io/badge/akit-capability_layer-black?style=for-the-badge&labelColor=f6f8fa&color=24292f">
+</picture>
+
+### The portable capability layer for AI companions.
+
+Give any AI tools that work everywhere — MCP on dev platforms, manual fallback everywhere else.
+
+<br>
+
+[![npm](https://img.shields.io/npm/v/@aman_asmuei/akit?style=flat-square&color=cb3837)](https://www.npmjs.com/package/@aman_asmuei/akit)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)](LICENSE)
+[![acore](https://img.shields.io/badge/part_of-acore_ecosystem-58a6ff.svg?style=flat-square)](https://github.com/amanasmuei/acore)
+
+</div>
+
+---
+
+## The Problem
+
+AI tools are platform-locked. MCP tools only work on MCP platforms. Function calling schemas differ between OpenAI, Anthropic, and Google. You can't take your AI's capabilities with you.
+
+## The Solution
+
+**akit** gives any AI a portable toolkit. One command to add tools. Works everywhere.
+
+```bash
+npx @aman_asmuei/akit add github
+```
+
+On **Claude Code / Cursor / Windsurf**: installs the real MCP server. Your AI gets actual tool access.
+
+On **ChatGPT / Gemini / other**: updates your `kit.md` capability manifest. Your AI knows what tools exist and guides you through manual steps.
+
+Same command. Same file. Different capabilities based on platform.
+
+---
+
+## The Ecosystem
+
+```
+acore (who it IS) + amem (what it KNOWS) + akit (what it CAN DO)
+```
+
+| Layer | Package | What it does |
+|:------|:--------|:-------------|
+| Identity | [acore](https://github.com/amanasmuei/acore) | Personality, values, relationship memory |
+| Memory | [amem](https://github.com/amanasmuei/amem) | Automated knowledge storage |
+| Tools | **akit** | Portable AI capabilities |
+
+Each works independently. Together they're a complete portable AI agent.
+
+---
+
+## Quick Start
+
+```bash
+# Search for tools
+npx @aman_asmuei/akit search database
+
+# Add a tool
+npx @aman_asmuei/akit add github
+
+# See your toolkit
+npx @aman_asmuei/akit show
+
+# Health check
+npx @aman_asmuei/akit doctor
+```
+
+## Commands
+
+| Command | What it does |
+|:--------|:------------|
+| `akit add <tool>` | Add a tool (auto-configures MCP if available) |
+| `akit remove <tool>` | Remove a tool |
+| `akit list` | List installed tools |
+| `akit search <query>` | Search the tool registry |
+| `akit show` | View your kit.md |
+| `akit doctor` | Health check your toolkit |
+
+## Available Tools
+
+| Tool | Category | What it does |
+|:-----|:---------|:-------------|
+| `web-search` | Search | Search the web for current information |
+| `brave-search` | Search | Private web search via Brave |
+| `github` | Development | PRs, issues, repos, code review |
+| `git` | Development | Log, diff, blame, branch management |
+| `filesystem` | Development | Read, write, search project files |
+| `memory` | Memory | Persistent AI memory via amem |
+| `postgres` | Data | Query PostgreSQL databases |
+| `sqlite` | Data | Query local SQLite databases |
+| `fetch` | Automation | HTTP requests to APIs |
+| `puppeteer` | Automation | Browser automation |
+| `slack` | Communication | Send and read Slack messages |
+| `notion` | Communication | Notion pages and databases |
+| `linear` | Development | Linear issues and projects |
+| `sentry` | Development | Error monitoring and triage |
+| `docker` | Automation | Container management |
+
+## How It Works
+
+### kit.md — The Capability Manifest
+
+Every tool you add gets recorded in `~/.akit/kit.md`:
+
+```markdown
+# My AI Toolkit
+
+## github
+- Do: Manage GitHub repos, PRs, issues, and code review
+- When: PRs, issues, repos, code review
+- How: MCP -> @modelcontextprotocol/server-github
+
+## filesystem
+- Do: Read, write, and search project files
+- When: coding, documentation
+- How: native (built into Claude Code, Cursor)
+
+---
+
+## Permissions
+- Never delete data without confirmation
+- Never push to main without approval
+- Ask before making external API calls that modify state
+```
+
+Your AI reads this file and knows what it can do.
+
+### Platform Behavior
+
+| Platform | What happens when you `akit add` |
+|:---------|:--------------------------------|
+| Claude Code | Writes MCP config to `~/.claude/settings.json` |
+| Cursor | Writes MCP config to `.cursor/mcp.json` |
+| Windsurf | Writes MCP config to `~/.windsurf/mcp.json` |
+| ChatGPT / Other | Updates kit.md with manual instructions |
+
+---
+
+## Privacy
+
+All data stays local. `~/.akit/` contains your toolkit config. No telemetry. No accounts. No cloud.
+
+## Contributing
+
+Contributions welcome! Add tools to the registry, improve platform support, or suggest features.
+
+## License
+
+[MIT](LICENSE)
+
+---
+
+<div align="center">
+
+**One command. Any tool. Every AI.**
+
+</div>

package/bin/akit.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/index.js";

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,591 @@
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/add.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+
+// src/lib/registry.ts
+var REGISTRY = [
+  {
+    name: "web-search",
+    description: "Search the web for current information",
+    category: "search",
+    mcp: {
+      package: "@anthropic/web-search",
+      command: "npx",
+      args: ["-y", "@anthropic/web-search"]
+    },
+    manual: "Ask user to search and paste results",
+    capabilities: ["research", "fact-checking", "current events"]
+  },
+  {
+    name: "brave-search",
+    description: "Private web search via Brave",
+    category: "search",
+    mcp: {
+      package: "@modelcontextprotocol/server-brave-search",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-brave-search"],
+      env: { BRAVE_API_KEY: "" }
+    },
+    manual: "Ask user to search Brave and paste results",
+    capabilities: ["research", "private search"],
+    envHint: "Set BRAVE_API_KEY from https://brave.com/search/api/"
+  },
+  {
+    name: "github",
+    description: "Manage GitHub repos, PRs, issues, and code review",
+    category: "development",
+    mcp: {
+      package: "@modelcontextprotocol/server-github",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-github"],
+      env: { GITHUB_TOKEN: "" }
+    },
+    manual: "Suggest gh CLI commands for user to run",
+    capabilities: ["PRs", "issues", "repos", "code review"],
+    envHint: "Set GITHUB_TOKEN from https://github.com/settings/tokens"
+  },
+  {
+    name: "git",
+    description: "Git operations \u2014 log, diff, blame, branch management",
+    category: "development",
+    mcp: {
+      package: "@modelcontextprotocol/server-git",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-git"]
+    },
+    manual: "Suggest git commands for user to run",
+    capabilities: ["log", "diff", "blame", "branch", "commit history"]
+  },
+  {
+    name: "filesystem",
+    description: "Read, write, and search project files",
+    category: "development",
+    mcp: {
+      package: "@modelcontextprotocol/server-filesystem",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-filesystem", "."]
+    },
+    manual: "Ask user to share file contents or run commands",
+    capabilities: ["read files", "write files", "search", "directory listing"]
+  },
+  {
+    name: "memory",
+    description: "Persistent AI memory via amem",
+    category: "memory",
+    mcp: {
+      package: "@aman_asmuei/amem",
+      command: "npx",
+      args: ["-y", "@aman_asmuei/amem"]
+    },
+    manual: "Use acore's built-in memory lifecycle rules",
+    capabilities: ["store observations", "recall context", "semantic search"]
+  },
+  {
+    name: "postgres",
+    description: "Query and manage PostgreSQL databases",
+    category: "data",
+    mcp: {
+      package: "@modelcontextprotocol/server-postgres",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-postgres"],
+      env: { DATABASE_URL: "" }
+    },
+    manual: "Ask user to run SQL queries and paste results",
+    capabilities: ["query", "schema inspection", "data analysis"],
+    envHint: "Set DATABASE_URL (e.g., postgresql://user:pass@localhost/db)"
+  },
+  {
+    name: "sqlite",
+    description: "Query local SQLite databases",
+    category: "data",
+    mcp: {
+      package: "@modelcontextprotocol/server-sqlite",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-sqlite"]
+    },
+    manual: "Ask user to run sqlite3 commands and paste results",
+    capabilities: ["query", "schema inspection", "local data"]
+  },
+  {
+    name: "fetch",
+    description: "Make HTTP requests to APIs and websites",
+    category: "automation",
+    mcp: {
+      package: "@modelcontextprotocol/server-fetch",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-fetch"]
+    },
+    manual: "Ask user to run curl commands and paste results",
+    capabilities: ["GET", "POST", "API calls", "web scraping"]
+  },
+  {
+    name: "puppeteer",
+    description: "Browser automation \u2014 screenshots, scraping, testing",
+    category: "automation",
+    mcp: {
+      package: "@modelcontextprotocol/server-puppeteer",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-puppeteer"]
+    },
+    manual: "Ask user to take screenshots or run browser scripts",
+    capabilities: ["screenshots", "form filling", "scraping", "testing"]
+  },
+  {
+    name: "slack",
+    description: "Send and read Slack messages",
+    category: "communication",
+    mcp: {
+      package: "@modelcontextprotocol/server-slack",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-slack"],
+      env: { SLACK_BOT_TOKEN: "" }
+    },
+    manual: "Ask user to check Slack and paste relevant messages",
+    capabilities: ["send messages", "read channels", "search"],
+    envHint: "Set SLACK_BOT_TOKEN from your Slack app settings"
+  },
+  {
+    name: "notion",
+    description: "Read and write Notion pages and databases",
+    category: "communication",
+    mcp: {
+      package: "@notionhq/notion-mcp-server",
+      command: "npx",
+      args: ["-y", "@notionhq/notion-mcp-server"],
+      env: { NOTION_API_KEY: "" }
+    },
+    manual: "Ask user to paste Notion content or share links",
+    capabilities: ["read pages", "create pages", "query databases"],
+    envHint: "Set NOTION_API_KEY from https://www.notion.so/my-integrations"
+  },
+  {
+    name: "linear",
+    description: "Manage Linear issues, projects, and cycles",
+    category: "development",
+    mcp: {
+      package: "@linear/mcp-server",
+      command: "npx",
+      args: ["-y", "@linear/mcp-server"],
+      env: { LINEAR_API_KEY: "" }
+    },
+    manual: "Ask user to check Linear and paste issue details",
+    capabilities: ["issues", "projects", "cycles", "search"],
+    envHint: "Set LINEAR_API_KEY from Linear settings \u2192 API"
+  },
+  {
+    name: "sentry",
+    description: "Monitor and triage application errors",
+    category: "development",
+    mcp: {
+      package: "@sentry/mcp-server",
+      command: "npx",
+      args: ["-y", "@sentry/mcp-server"],
+      env: { SENTRY_AUTH_TOKEN: "" }
+    },
+    manual: "Ask user to paste Sentry error details",
+    capabilities: ["error monitoring", "issue triage", "stack traces"],
+    envHint: "Set SENTRY_AUTH_TOKEN from Sentry settings \u2192 API keys"
+  },
+  {
+    name: "docker",
+    description: "Manage Docker containers and images",
+    category: "automation",
+    mcp: {
+      package: "@modelcontextprotocol/server-docker",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-docker"]
+    },
+    manual: "Suggest docker commands for user to run",
+    capabilities: ["containers", "images", "compose", "logs"]
+  }
+];
+function findTool(name) {
+  return REGISTRY.find((t) => t.name === name);
+}
+function searchTools(query) {
+  const q = query.toLowerCase();
+  return REGISTRY.filter(
+    (t) => t.name.includes(q) || t.description.toLowerCase().includes(q) || t.category.includes(q) || t.capabilities.some((c) => c.toLowerCase().includes(q))
+  );
+}
+
+// src/lib/platform.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+function detectPlatform() {
+  const cwd = process.cwd();
+  const acoreConfig = path.join(cwd, ".acore", "config.json");
+  if (fs.existsSync(acoreConfig)) {
+    try {
+      const raw = fs.readFileSync(acoreConfig, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.platform === "string") {
+        const p7 = parsed.platform;
+        if (p7 === "claude-code" || p7 === "cursor" || p7 === "windsurf") return p7;
+      }
+    } catch {
+    }
+  }
+  if (fs.existsSync(path.join(cwd, "CLAUDE.md"))) return "claude-code";
+  if (fs.existsSync(path.join(cwd, ".cursorrules"))) return "cursor";
+  if (fs.existsSync(path.join(cwd, ".windsurfrules"))) return "windsurf";
+  return "other";
+}
+function isMcpPlatform(platform) {
+  return platform === "claude-code" || platform === "cursor" || platform === "windsurf";
+}
+function getMcpConfigPath(platform) {
+  switch (platform) {
+    case "claude-code":
+      return path.join(os.homedir(), ".claude", "settings.json");
+    case "cursor":
+      return path.join(process.cwd(), ".cursor", "mcp.json");
+    case "windsurf":
+      return path.join(os.homedir(), ".windsurf", "mcp.json");
+    default:
+      return null;
+  }
+}
+function addMcpServer(platform, name, config) {
+  const configPath = getMcpConfigPath(platform);
+  if (!configPath) return;
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  let existing = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      existing = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    } catch {
+    }
+  }
+  if (platform === "claude-code") {
+    const mcpServers = existing.mcpServers ?? {};
+    mcpServers[name] = config;
+    existing.mcpServers = mcpServers;
+  } else {
+    const mcpServers = existing.mcpServers ?? {};
+    mcpServers[name] = config;
+    existing.mcpServers = mcpServers;
+  }
+  fs.writeFileSync(configPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+}
+function removeMcpServer(platform, name) {
+  const configPath = getMcpConfigPath(platform);
+  if (!configPath || !fs.existsSync(configPath)) return;
+  try {
+    const existing = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    const mcpServers = existing.mcpServers ?? {};
+    delete mcpServers[name];
+    existing.mcpServers = mcpServers;
+    fs.writeFileSync(configPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+  } catch {
+  }
+}
+
+// src/lib/kit.ts
+import fs3 from "fs";
+
+// src/lib/paths.ts
+import fs2 from "fs";
+import path2 from "path";
+import os2 from "os";
+function getGlobalDir() {
+  return path2.join(os2.homedir(), ".akit");
+}
+function globalConfigExists() {
+  return fs2.existsSync(path2.join(getGlobalDir(), "kit.md"));
+}
+function getKitPath() {
+  return path2.join(getGlobalDir(), "kit.md");
+}
+function getInstalledToolsPath() {
+  return path2.join(getGlobalDir(), "installed.json");
+}
+function acoreExists() {
+  const acoreDir = path2.join(os2.homedir(), ".acore");
+  return fs2.existsSync(path2.join(acoreDir, "core.md"));
+}
+
+// src/lib/kit.ts
+function loadInstalledTools() {
+  const filePath = getInstalledToolsPath();
+  if (!fs3.existsSync(filePath)) return [];
+  try {
+    return JSON.parse(fs3.readFileSync(filePath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function saveInstalledTools(tools) {
+  const dir = getGlobalDir();
+  fs3.mkdirSync(dir, { recursive: true });
+  fs3.writeFileSync(getInstalledToolsPath(), JSON.stringify(tools, null, 2) + "\n", "utf-8");
+}
+function addInstalledTool(name, mcpConfigured) {
+  const tools = loadInstalledTools();
+  const existing = tools.findIndex((t) => t.name === name);
+  const entry = {
+    name,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    mcpConfigured
+  };
+  if (existing >= 0) {
+    tools[existing] = entry;
+  } else {
+    tools.push(entry);
+  }
+  saveInstalledTools(tools);
+}
+function removeInstalledTool(name) {
+  const tools = loadInstalledTools().filter((t) => t.name !== name);
+  saveInstalledTools(tools);
+}
+function isToolInstalled(name) {
+  return loadInstalledTools().some((t) => t.name === name);
+}
+function generateKitMd(tools, entries) {
+  const lines = ["# My AI Toolkit", ""];
+  if (tools.length === 0) {
+    lines.push("No tools installed yet. Run `akit add <tool>` to get started.");
+    lines.push("");
+    return lines.join("\n");
+  }
+  for (const tool of tools) {
+    const entry = entries.find((e) => e.name === tool.name);
+    if (!entry) continue;
+    lines.push(`## ${entry.name}`);
+    lines.push(`- Do: ${entry.description}`);
+    lines.push(`- When: ${entry.capabilities.join(", ")}`);
+    if (tool.mcpConfigured && entry.mcp) {
+      lines.push(`- How: MCP \u2192 ${entry.mcp.package}`);
+    } else {
+      lines.push(`- How: ${entry.manual}`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("## Permissions");
+  lines.push("- Never delete data without confirmation");
+  lines.push("- Never push to main without approval");
+  lines.push("- Ask before making external API calls that modify state");
+  lines.push("");
+  return lines.join("\n");
+}
+function writeKitMd(content) {
+  const dir = getGlobalDir();
+  fs3.mkdirSync(dir, { recursive: true });
+  fs3.writeFileSync(getKitPath(), content, "utf-8");
+}
+
+// src/commands/add.ts
+async function addCommand(toolName) {
+  p.intro(pc.bold("akit") + " \u2014 adding " + pc.cyan(toolName));
+  const tool = findTool(toolName);
+  if (!tool) {
+    p.log.error(`Tool "${toolName}" not found in registry.`);
+    p.log.info(`Run ${pc.bold("akit search " + toolName)} to find similar tools.`);
+    p.outro("");
+    return;
+  }
+  if (isToolInstalled(toolName)) {
+    p.log.warning(`${pc.bold(toolName)} is already installed.`);
+    p.outro("");
+    return;
+  }
+  const platform = detectPlatform();
+  const hasMcp = isMcpPlatform(platform) && tool.mcp !== null;
+  p.log.info(`Tool: ${pc.bold(tool.description)}`);
+  p.log.info(`Capabilities: ${tool.capabilities.join(", ")}`);
+  if (hasMcp) {
+    p.log.info(`Platform: ${pc.green(platform)} (MCP supported)`);
+    const mcp = tool.mcp;
+    addMcpServer(platform, toolName, {
+      command: mcp.command || "npx",
+      args: mcp.args || ["-y", mcp.package],
+      ...mcp.env && Object.keys(mcp.env).length > 0 ? { env: mcp.env } : {}
+    });
+    p.log.success(`Added MCP config for ${pc.bold(toolName)}`);
+    if (tool.envHint) {
+      p.log.warning(tool.envHint);
+    }
+  } else {
+    p.log.info(`Platform: ${pc.dim(platform)} (manual mode)`);
+    p.log.info(`Fallback: ${tool.manual}`);
+  }
+  addInstalledTool(toolName, hasMcp);
+  const installed = loadInstalledTools();
+  const entries = installed.map((t) => findTool(t.name)).filter(Boolean);
+  const kitContent = generateKitMd(installed, entries);
+  writeKitMd(kitContent);
+  p.log.success(`Updated ${pc.dim("~/.akit/kit.md")}`);
+  p.outro("Done.");
+}
+
+// src/commands/remove.ts
+import * as p2 from "@clack/prompts";
+import pc2 from "picocolors";
+async function removeCommand(toolName) {
+  p2.intro(pc2.bold("akit") + " \u2014 removing " + pc2.cyan(toolName));
+  if (!isToolInstalled(toolName)) {
+    p2.log.error(`Tool "${toolName}" is not installed.`);
+    p2.outro("");
+    return;
+  }
+  const platform = detectPlatform();
+  if (isMcpPlatform(platform)) {
+    removeMcpServer(platform, toolName);
+    p2.log.success(`Removed MCP config for ${pc2.bold(toolName)}`);
+  }
+  removeInstalledTool(toolName);
+  const installed = loadInstalledTools();
+  const entries = installed.map((t) => findTool(t.name)).filter(Boolean);
+  const kitContent = generateKitMd(installed, entries);
+  writeKitMd(kitContent);
+  p2.log.success(`Updated ${pc2.dim("~/.akit/kit.md")}`);
+  p2.outro("Done.");
+}
+
+// src/commands/list.ts
+import * as p3 from "@clack/prompts";
+import pc3 from "picocolors";
+function listCommand() {
+  const installed = loadInstalledTools();
+  if (installed.length === 0) {
+    p3.intro(pc3.bold("akit") + " \u2014 your AI toolkit");
+    p3.log.info("No tools installed yet.");
+    p3.log.info(`Run ${pc3.bold("akit search <query>")} to find tools.`);
+    p3.log.info(`Run ${pc3.bold("akit add <tool>")} to install one.`);
+    p3.outro("");
+    return;
+  }
+  p3.intro(pc3.bold("akit") + " \u2014 " + installed.length + " tools installed");
+  for (const tool of installed) {
+    const entry = findTool(tool.name);
+    const desc = entry ? entry.description : "Unknown tool";
+    const mode = tool.mcpConfigured ? pc3.green("MCP") : pc3.dim("manual");
+    p3.log.info(`${pc3.bold(tool.name)} \u2014 ${desc} [${mode}]`);
+  }
+  p3.outro("");
+}
+
+// src/commands/search.ts
+import * as p4 from "@clack/prompts";
+import pc4 from "picocolors";
+function searchCommand(query) {
+  const results = searchTools(query);
+  if (results.length === 0) {
+    p4.intro(pc4.bold("akit search") + " \u2014 no results for " + pc4.cyan(query));
+    p4.log.info(`${REGISTRY.length} tools in registry, none matched "${query}".`);
+    p4.outro("");
+    return;
+  }
+  p4.intro(pc4.bold("akit search") + " \u2014 " + results.length + " results for " + pc4.cyan(query));
+  for (const tool of results) {
+    const installed = isToolInstalled(tool.name);
+    const status = installed ? pc4.green(" [installed]") : "";
+    const mcp = tool.mcp ? pc4.dim(" (MCP)") : "";
+    p4.log.info(
+      `${pc4.bold(tool.name)}${status}${mcp} \u2014 ${tool.description}`
+    );
+    p4.log.message(`  ${pc4.dim(tool.capabilities.join(", "))}`);
+  }
+  p4.outro("");
+}
+
+// src/commands/show.ts
+import * as p5 from "@clack/prompts";
+import pc5 from "picocolors";
+import fs4 from "fs";
+function showCommand() {
+  if (!globalConfigExists()) {
+    p5.intro(pc5.bold("akit show"));
+    p5.log.info("No toolkit configured yet.");
+    p5.log.info(`Run ${pc5.bold("akit add <tool>")} to get started.`);
+    p5.outro("");
+    return;
+  }
+  const content = fs4.readFileSync(getKitPath(), "utf-8");
+  p5.intro(pc5.bold("akit") + " \u2014 your toolkit");
+  console.log(content);
+  p5.outro("");
+}
+
+// src/commands/doctor.ts
+import * as p6 from "@clack/prompts";
+import pc6 from "picocolors";
+import fs5 from "fs";
+function doctorCommand() {
+  p6.intro(pc6.bold("akit doctor") + " \u2014 health check");
+  let score = 10;
+  const installed = loadInstalledTools();
+  const platform = detectPlatform();
+  if (installed.length === 0) {
+    p6.log.warning("No tools installed \u2014 run " + pc6.bold("akit add <tool>"));
+    score -= 2;
+  } else {
+    p6.log.success(`${installed.length} tools installed`);
+  }
+  if (globalConfigExists()) {
+    p6.log.success("kit.md exists");
+  } else {
+    p6.log.error("kit.md not found \u2014 run " + pc6.bold("akit add <tool>") + " to create it");
+    score -= 2;
+  }
+  if (isMcpPlatform(platform)) {
+    p6.log.success(`Platform: ${pc6.bold(platform)} (MCP supported)`);
+  } else {
+    p6.log.warning(`Platform: ${pc6.dim(platform)} \u2014 tools will run in manual mode`);
+    score -= 1;
+  }
+  if (isMcpPlatform(platform)) {
+    const configPath = getMcpConfigPath(platform);
+    if (configPath && fs5.existsSync(configPath)) {
+      p6.log.success("MCP config file exists");
+    } else {
+      p6.log.warning("MCP config file not found \u2014 tools may not be connected");
+      score -= 1;
+    }
+  }
+  for (const tool of installed) {
+    const entry = findTool(tool.name);
+    if (entry?.mcp?.env) {
+      for (const envVar of Object.keys(entry.mcp.env)) {
+        if (!process.env[envVar]) {
+          p6.log.warning(`${pc6.bold(tool.name)}: ${envVar} not set \u2014 ${entry.envHint || "set this environment variable"}`);
+          score -= 1;
+        }
+      }
+    }
+  }
+  if (acoreExists()) {
+    p6.log.success("acore detected \u2014 identity layer connected");
+  } else {
+    p6.log.info("acore not found \u2014 run " + pc6.bold("npx @aman_asmuei/acore") + " for AI identity");
+  }
+  score = Math.max(0, score);
+  const scoreColor = score >= 8 ? pc6.green : score >= 5 ? pc6.yellow : pc6.red;
+  p6.log.message("");
+  p6.log.info(`Score: ${scoreColor(`${score}/10`)}`);
+  p6.outro("");
+}
+
+// src/index.ts
+var program = new Command();
+program.name("akit").description("The portable capability layer for AI companions").version("0.1.0").action(() => {
+  if (globalConfigExists()) {
+    showCommand();
+  } else {
+    listCommand();
+  }
+});
+program.command("add <tool>").description("Add a tool to your AI toolkit").action((tool) => addCommand(tool));
+program.command("remove <tool>").description("Remove a tool from your toolkit").action((tool) => removeCommand(tool));
+program.command("list").description("List installed tools").action(() => listCommand());
+program.command("search <query>").description("Search available tools in the registry").action((query) => searchCommand(query));
+program.command("show").description("View your current kit.md").action(() => showCommand());
+program.command("doctor").description("Health check your toolkit configuration").action(() => doctorCommand());
+program.parse();

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@aman_asmuei/akit",
+  "version": "0.1.0",
+  "description": "The portable capability layer for AI companions — give any AI tools that work everywhere",
+  "type": "module",
+  "bin": {
+    "akit": "./bin/akit.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "ai",
+    "llm",
+    "tools",
+    "mcp",
+    "capabilities",
+    "cli",
+    "acore"
+  ],
+  "author": "Aman Asmuei",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/amanasmuei/akit.git"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.1",
+    "commander": "^13.1.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}