@0dai-dev/cli 1.2.1

package/README.md

@@ -0,0 +1,39 @@
+# 0dai
+
+One config layer for 5 AI agent CLIs — Claude Code, Codex, OpenCode, Gemini, Aider.
+
+## Install
+
+```bash
+npm install -g @0dai-dev/cli
+```
+
+## Usage
+
+```bash
+cd your-project
+0dai init       # detect stack, generate ai/ layer + native configs
+0dai sync       # update after changes
+0dai detect     # show detected stack
+0dai doctor     # check health
+0dai status     # maturity, swarm tasks, session
+```
+
+## What it does
+
+`0dai init` sends your project metadata (file names + package.json) to the API and generates:
+
+- `ai/` — manifests, personas, skills, playbooks, delegation policy
+- `.claude/` — settings, agents, hooks, rules
+- `.codex/` — config, agents
+- `.gemini/` — settings, agents
+- `.aider/` — config, agents
+- `AGENTS.md`, `.mcp.json`
+
+Your source code is never sent. Only file names and package manifests.
+
+## Links
+
+- Website: https://0dai.dev
+- Docs: https://docs.0dai.dev
+- API: https://api.0dai.dev

package/bin/0dai.js

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+"use strict";
+
+const https = require("https");
+const http = require("http");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const VERSION = "1.2.1";
+const API_URL = process.env.ODAI_API_URL || "https://api.0dai.dev";
+const CONFIG_DIR = path.join(os.homedir(), ".0dai");
+const AUTH_FILE = path.join(CONFIG_DIR, "auth.json");
+
+const MANIFEST_FILES = [
+  "package.json", "go.mod", "pyproject.toml", "requirements.txt",
+  "pubspec.yaml", "Cargo.toml", "next.config.js", "next.config.mjs",
+  "next.config.ts", "tsconfig.json", "Makefile", "docker-compose.yml",
+  "Dockerfile", "pom.xml", "build.gradle",
+];
+
+const PROBE_DIRS = [
+  "src", "lib", "app", "apps", "packages", "services",
+  "cmd", "internal", "web", "frontend", "backend",
+  "tests", "test", "spec", "__tests__",
+  "infra", "deploy", "docker", ".github",
+  "android", "ios", "linux", "macos", "windows",
+];
+
+function apiCall(endpoint, data) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(endpoint, API_URL);
+    const mod = url.protocol === "https:" ? https : http;
+    const body = data ? JSON.stringify(data) : null;
+    const headers = { "Content-Type": "application/json" };
+
+    try {
+      const auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf8"));
+      const token = auth.api_key || auth.token;
+      if (token) headers["Authorization"] = `Bearer ${token}`;
+    } catch {}
+
+    const opts = {
+      hostname: url.hostname,
+      port: url.port || (url.protocol === "https:" ? 443 : 80),
+      path: url.pathname,
+      method: body ? "POST" : "GET",
+      headers,
+      timeout: 30000,
+    };
+    if (body) opts.headers["Content-Length"] = Buffer.byteLength(body);
+
+    const req = mod.request(opts, (res) => {
+      let chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => {
+        try {
+          resolve(JSON.parse(Buffer.concat(chunks).toString()));
+        } catch {
+          resolve({ error: `HTTP ${res.statusCode}` });
+        }
+      });
+    });
+    req.on("error", (e) => resolve({ error: `${e.message}. Is ${API_URL} reachable?` }));
+    req.on("timeout", () => { req.destroy(); resolve({ error: "timeout" }); });
+    if (body) req.write(body);
+    req.end();
+  });
+}
+
+function collectMetadata(target) {
+  const projectFiles = [];
+  const fileContents = {};
+
+  for (const d of PROBE_DIRS) {
+    try { if (fs.statSync(path.join(target, d)).isDirectory()) projectFiles.push(d + "/"); } catch {}
+  }
+
+  for (const f of MANIFEST_FILES) {
+    const p = path.join(target, f);
+    try {
+      const stat = fs.statSync(p);
+      if (stat.isFile()) {
+        projectFiles.push(f);
+        const content = fs.readFileSync(p, "utf8");
+        if (content.length < 10000) fileContents[f] = content;
+      }
+    } catch {}
+  }
+
+  const clis = [];
+  for (const cli of ["claude", "codex", "opencode", "gemini", "aider"]) {
+    try {
+      const { execSync } = require("child_process");
+      execSync(`which ${cli}`, { stdio: "ignore" });
+      clis.push(cli);
+    } catch {}
+  }
+
+  return { projectFiles, fileContents, clis };
+}
+
+function writeFiles(target, files) {
+  let created = 0, updated = 0, unchanged = 0;
+  for (const [rel, content] of Object.entries(files)) {
+    const p = path.join(target, rel);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    try {
+      if (fs.existsSync(p) && fs.readFileSync(p, "utf8") === content) {
+        unchanged++;
+        continue;
+      }
+      if (fs.existsSync(p)) updated++;
+      else created++;
+    } catch { created++; }
+    fs.writeFileSync(p, content, "utf8");
+  }
+  console.log(`[0dai] ${created} created, ${updated} updated, ${unchanged} unchanged`);
+  return created + updated;
+}
+
+async function cmdInit(target) {
+  if (fs.existsSync(path.join(target, "ai", "VERSION"))) {
+    const v = fs.readFileSync(path.join(target, "ai", "VERSION"), "utf8").trim();
+    console.log(`[0dai] ai/ layer already exists (v${v}). Run '0dai sync' to update.`);
+    return;
+  }
+
+  console.log("[0dai] collecting project metadata...");
+  const { projectFiles, fileContents, clis } = collectMetadata(target);
+
+  console.log(`[0dai] sending to API (${projectFiles.length} files, ${clis.length} CLIs)...`);
+  const result = await apiCall("/v1/init", {
+    project_files: projectFiles,
+    file_contents: fileContents,
+    available_clis: clis,
+  });
+
+  if (result.error) { console.error(`[0dai] error: ${result.error}`); process.exit(1); }
+
+  console.log(`[0dai] detected: ${result.stack || "?"}`);
+  writeFiles(target, result.files || {});
+
+  // Add to .gitignore
+  const gi = path.join(target, ".gitignore");
+  try {
+    const text = fs.existsSync(gi) ? fs.readFileSync(gi, "utf8") : "";
+    if (!text.includes(".0dai")) fs.appendFileSync(gi, "\n.0dai/\n");
+  } catch {}
+
+  console.log(`[0dai] initialized (${result.file_count || "?"} files)`);
+  console.log("  skills: /build /review /status /feedback /bugfix /delegate");
+}
+
+async function cmdSync(target) {
+  const { projectFiles, fileContents, clis } = collectMetadata(target);
+
+  let version = "unknown", stack = "generic", agents = [];
+  try { version = fs.readFileSync(path.join(target, "ai", "VERSION"), "utf8").trim(); } catch {}
+  try {
+    const d = JSON.parse(fs.readFileSync(path.join(target, "ai", "manifest", "discovery.json"), "utf8"));
+    stack = d.stack || "generic";
+    agents = d.selected_agents || [];
+  } catch {}
+
+  // Collect current ai/ files
+  const currentFiles = {};
+  const aiDir = path.join(target, "ai");
+  if (fs.existsSync(aiDir)) {
+    const walk = (dir) => {
+      for (const f of fs.readdirSync(dir, { withFileTypes: true })) {
+        const p = path.join(dir, f.name);
+        if (f.isDirectory()) walk(p);
+        else {
+          try {
+            const stat = fs.statSync(p);
+            if (stat.size < 10000) currentFiles[path.relative(target, p)] = fs.readFileSync(p, "utf8");
+          } catch {}
+        }
+      }
+    };
+    walk(aiDir);
+  }
+
+  const result = await apiCall("/v1/sync", {
+    ai_version: version, stack, agents: agents.length ? agents : clis,
+    current_files: currentFiles, file_contents: fileContents,
+  });
+
+  if (result.error) { console.error(`[0dai] error: ${result.error}`); process.exit(1); }
+
+  const updated = result.files_updated || {};
+  if (Object.keys(updated).length) writeFiles(target, updated);
+  else console.log("[0dai] already up to date");
+}
+
+async function cmdDetect(target) {
+  const { projectFiles } = collectMetadata(target);
+  const result = await apiCall("/v1/detect", { files: projectFiles });
+  if (result.error) { console.error(`[0dai] error: ${result.error}`); return; }
+  console.log(`stack: ${result.stack || "?"}`);
+  console.log(`clis: ${(result.available_clis || []).join(",")}`);
+}
+
+function cmdDoctor(target) {
+  const ai = path.join(target, "ai");
+  if (!fs.existsSync(ai)) { console.log("[0dai] no ai/ layer. Run '0dai init' first."); return; }
+  let v = "?";
+  try { v = fs.readFileSync(path.join(ai, "VERSION"), "utf8").trim(); } catch {}
+  const checks = {
+    "ai/VERSION": fs.existsSync(path.join(ai, "VERSION")),
+    "ai/manifest/project.yaml": fs.existsSync(path.join(ai, "manifest", "project.yaml")),
+    "ai/manifest/commands.yaml": fs.existsSync(path.join(ai, "manifest", "commands.yaml")),
+    "ai/manifest/discovery.json": fs.existsSync(path.join(ai, "manifest", "discovery.json")),
+    ".claude/settings.json": fs.existsSync(path.join(target, ".claude", "settings.json")),
+    "AGENTS.md": fs.existsSync(path.join(target, "AGENTS.md")),
+  };
+  const ok = Object.values(checks).every(Boolean);
+  console.log(`[0dai] v${v} — ${ok ? "healthy" : "issues found"}`);
+  for (const [name, exists] of Object.entries(checks)) console.log(`  ${exists ? "ok" : "MISSING"}: ${name}`);
+}
+
+function cmdStatus(target) {
+  const ai = path.join(target, "ai");
+  let v = "?", stack = "?";
+  try { v = fs.readFileSync(path.join(ai, "VERSION"), "utf8").trim(); } catch {}
+  try { stack = JSON.parse(fs.readFileSync(path.join(ai, "manifest", "discovery.json"), "utf8")).stack || "?"; } catch {}
+  console.log(`[0dai] v${v} | stack: ${stack}`);
+
+  const count = (dir) => { try { return fs.readdirSync(dir).filter(f => f.endsWith(".json")).length; } catch { return 0; } };
+  const q = count(path.join(ai, "swarm", "queue"));
+  const a = count(path.join(ai, "swarm", "active"));
+  const d = count(path.join(ai, "swarm", "done"));
+  if (q || a || d) console.log(`  swarm: ${q} queued, ${a} active, ${d} done`);
+
+  try {
+    const s = JSON.parse(fs.readFileSync(path.join(ai, "sessions", "active.json"), "utf8"));
+    console.log(`  session: ${(s.task || {}).goal || "?"} (agent: ${s.current_agent || "?"})`);
+  } catch {}
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  let target = process.cwd();
+  const ti = args.indexOf("--target");
+  if (ti >= 0 && args[ti + 1]) { target = path.resolve(args[ti + 1]); args.splice(ti, 2); }
+
+  const cmd = args[0] || "help";
+
+  switch (cmd) {
+    case "init": await cmdInit(target); break;
+    case "sync": await cmdSync(target); break;
+    case "detect": await cmdDetect(target); break;
+    case "doctor": cmdDoctor(target); break;
+    case "status": cmdStatus(target); break;
+    case "--version": console.log(`0dai ${VERSION}`); break;
+    case "help": case "--help": case "-h":
+      console.log(`0dai v${VERSION} — One config for 5 AI agent CLIs\n`);
+      console.log("Commands:");
+      console.log("  init     Initialize ai/ layer (via API)");
+      console.log("  sync     Update ai/ layer (via API)");
+      console.log("  detect   Show detected stack");
+      console.log("  doctor   Check health");
+      console.log("  status   Show maturity, swarm, session");
+      console.log("  --version\n");
+      console.log("https://0dai.dev");
+      break;
+    default:
+      console.error(`[0dai] unknown command: ${cmd}. Run '0dai --help'`);
+      process.exit(1);
+  }
+}
+
+main().catch((e) => { console.error(`[0dai] ${e.message}`); process.exit(1); });

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@0dai-dev/cli",
+  "version": "1.2.1",
+  "description": "One config layer for 5 AI agent CLIs — Claude Code, Codex, OpenCode, Gemini, Aider",
+  "bin": {
+    "0dai": "./bin/0dai.js"
+  },
+  "keywords": ["ai", "agents", "claude", "codex", "gemini", "aider", "developer-tools", "mcp"],
+  "author": "0dai-dev <dev@0dai.dev>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/0dai-dev/0dai"
+  },
+  "homepage": "https://0dai.dev",
+  "engines": {
+    "node": ">=16"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md"
+  ]
+}