@devness/useai-cli 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 useai.dev
+
+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/dist/index.js

@@ -0,0 +1,971 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command8 } from "commander";
+
+// ../shared/dist/constants/paths.js
+import { join } from "path";
+import { homedir } from "os";
+var USEAI_DIR = join(homedir(), ".useai");
+var DATA_DIR = join(USEAI_DIR, "data");
+var ACTIVE_DIR = join(DATA_DIR, "active");
+var SEALED_DIR = join(DATA_DIR, "sealed");
+var KEYSTORE_FILE = join(USEAI_DIR, "keystore.json");
+var CONFIG_FILE = join(USEAI_DIR, "config.json");
+var SESSIONS_FILE = join(DATA_DIR, "sessions.json");
+var MILESTONES_FILE = join(DATA_DIR, "milestones.json");
+
+// ../shared/dist/constants/version.js
+var VERSION = "0.3.0";
+
+// ../shared/dist/constants/defaults.js
+var DEFAULT_CONFIG = {
+  milestone_tracking: true,
+  auto_sync: true
+};
+var DEFAULT_SYNC_INTERVAL_HOURS = 24;
+
+// src/commands/stats.ts
+import { Command } from "commander";
+import chalk2 from "chalk";
+
+// ../shared/dist/utils/fs.js
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "fs";
+function ensureDir() {
+  for (const dir of [USEAI_DIR, DATA_DIR, ACTIVE_DIR, SEALED_DIR]) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+function readJson(path, fallback) {
+  try {
+    if (!existsSync(path))
+      return fallback;
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function writeJson(path, data) {
+  ensureDir();
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
+  renameSync(tmp, path);
+}
+
+// ../shared/dist/utils/format.js
+function formatDuration(seconds) {
+  if (seconds < 60)
+    return `${seconds}s`;
+  const mins = Math.round(seconds / 60);
+  if (mins < 60)
+    return `${mins}m`;
+  const hrs = Math.floor(mins / 60);
+  const remainMins = mins % 60;
+  return `${hrs}h ${remainMins}m`;
+}
+
+// ../shared/dist/utils/id.js
+import { randomUUID } from "crypto";
+
+// src/services/stats.service.ts
+function getStats() {
+  const sessions = readJson(SESSIONS_FILE, []);
+  let totalSeconds = 0;
+  const byClient = {};
+  const byLanguage = {};
+  const byTaskType = {};
+  for (const s of sessions) {
+    totalSeconds += s.duration_seconds;
+    byClient[s.client] = (byClient[s.client] ?? 0) + s.duration_seconds;
+    for (const lang of s.languages) {
+      byLanguage[lang] = (byLanguage[lang] ?? 0) + s.duration_seconds;
+    }
+    byTaskType[s.task_type] = (byTaskType[s.task_type] ?? 0) + s.duration_seconds;
+  }
+  const currentStreak = calculateStreak(sessions);
+  return {
+    totalHours: totalSeconds / 3600,
+    totalSessions: sessions.length,
+    byClient,
+    byLanguage,
+    byTaskType,
+    currentStreak
+  };
+}
+function calculateStreak(sessions) {
+  if (sessions.length === 0) return 0;
+  const days = /* @__PURE__ */ new Set();
+  for (const s of sessions) {
+    days.add(s.started_at.slice(0, 10));
+  }
+  const sorted = [...days].sort().reverse();
+  if (sorted.length === 0) return 0;
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const yesterday = new Date(Date.now() - 864e5).toISOString().slice(0, 10);
+  if (sorted[0] !== today && sorted[0] !== yesterday) return 0;
+  let streak = 1;
+  for (let i = 1; i < sorted.length; i++) {
+    const prev = new Date(sorted[i - 1]);
+    const curr = new Date(sorted[i]);
+    const diffDays = (prev.getTime() - curr.getTime()) / 864e5;
+    if (diffDays === 1) {
+      streak++;
+    } else {
+      break;
+    }
+  }
+  return streak;
+}
+
+// src/utils/display.ts
+import chalk from "chalk";
+function header(text) {
+  return chalk.bold.cyan(`
+  ${text}
+  ${"\u2500".repeat(text.length)}`);
+}
+function table(rows) {
+  const maxLabel = Math.max(...rows.map(([label]) => label.length));
+  return rows.map(([label, value]) => `  ${chalk.dim(label.padEnd(maxLabel))}  ${value}`).join("\n");
+}
+function success(text) {
+  return chalk.green(`  ${text}`);
+}
+function error(text) {
+  return chalk.red(`  ${text}`);
+}
+function info(text) {
+  return chalk.dim(`  ${text}`);
+}
+
+// src/commands/stats.ts
+var statsCommand = new Command("stats").description("Show aggregated AI development stats").action(() => {
+  const stats = getStats();
+  if (stats.totalSessions === 0) {
+    console.log(info("No sessions recorded yet."));
+    return;
+  }
+  console.log(header("AI Development Stats"));
+  console.log(
+    table([
+      ["Total time", chalk2.bold(formatDuration(Math.round(stats.totalHours * 3600)))],
+      ["Sessions", chalk2.bold(String(stats.totalSessions))],
+      ["Current streak", chalk2.bold(`${stats.currentStreak} day${stats.currentStreak !== 1 ? "s" : ""}`)]
+    ])
+  );
+  const clientEntries = Object.entries(stats.byClient).sort((a, b) => b[1] - a[1]);
+  if (clientEntries.length > 0) {
+    console.log(header("By Client"));
+    console.log(
+      table(clientEntries.map(([name, secs]) => [name, formatDuration(secs)]))
+    );
+  }
+  const langEntries = Object.entries(stats.byLanguage).sort((a, b) => b[1] - a[1]);
+  if (langEntries.length > 0) {
+    console.log(header("By Language"));
+    console.log(
+      table(langEntries.map(([name, secs]) => [name, formatDuration(secs)]))
+    );
+  }
+  const taskEntries = Object.entries(stats.byTaskType).sort((a, b) => b[1] - a[1]);
+  if (taskEntries.length > 0) {
+    console.log(header("By Task Type"));
+    console.log(
+      table(taskEntries.map(([name, secs]) => [name, formatDuration(secs)]))
+    );
+  }
+  console.log("");
+});
+
+// src/commands/status.ts
+import { Command as Command2 } from "commander";
+import { existsSync as existsSync2, statSync, readdirSync } from "fs";
+import chalk3 from "chalk";
+
+// src/services/config.service.ts
+var DEFAULT_USEAI_CONFIG = {
+  ...DEFAULT_CONFIG,
+  sync_interval_hours: DEFAULT_SYNC_INTERVAL_HOURS
+};
+function getConfig() {
+  return readJson(CONFIG_FILE, DEFAULT_USEAI_CONFIG);
+}
+function saveConfig(config) {
+  writeJson(CONFIG_FILE, config);
+}
+function updateConfig(updates) {
+  const config = getConfig();
+  const updated = { ...config, ...updates };
+  saveConfig(updated);
+  return updated;
+}
+
+// src/commands/status.ts
+function dirSize(dirPath) {
+  if (!existsSync2(dirPath)) return 0;
+  let total = 0;
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true, recursive: true });
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        const parentPath = entry.parentPath ?? entry.path ?? dirPath;
+        try {
+          total += statSync(`${parentPath}/${entry.name}`).size;
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return total;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+var statusCommand = new Command2("status").description("Full transparency dashboard \u2014 see everything stored locally").action(() => {
+  const sessions = readJson(SESSIONS_FILE, []);
+  const milestones = readJson(MILESTONES_FILE, []);
+  const config = getConfig();
+  const totalSeconds = sessions.reduce((sum, s) => sum + s.duration_seconds, 0);
+  const unpublished = milestones.filter((m) => !m.published).length;
+  const published = milestones.filter((m) => m.published).length;
+  const storageSize = dirSize(USEAI_DIR);
+  console.log(header("useai Status"));
+  console.log(
+    table([
+      ["Sessions recorded", chalk3.bold(String(sessions.length))],
+      ["Total tracked time", chalk3.bold(formatDuration(totalSeconds))],
+      ["Milestones", chalk3.bold(`${unpublished} unpublished, ${published} published`)],
+      ["Local storage", chalk3.bold(formatBytes(storageSize))],
+      ["Data directory", chalk3.dim(DATA_DIR)]
+    ])
+  );
+  console.log(header("Settings"));
+  console.log(
+    table([
+      ["Milestone tracking", config.milestone_tracking ? chalk3.green("on") : chalk3.red("off")],
+      ["Auto sync", config.auto_sync ? chalk3.green("on") : chalk3.red("off")],
+      ["Sync interval", `${config.sync_interval_hours}h`],
+      ["Last sync", config.last_sync_at ?? chalk3.dim("never")],
+      ["Logged in", config.auth ? chalk3.green(config.auth.user.email) : chalk3.dim("no")]
+    ])
+  );
+  console.log(header("Privacy"));
+  console.log(
+    info("useai NEVER captures code, file contents, prompts, or responses.")
+  );
+  console.log(
+    info("Only durations, tool names, languages, and task types are recorded.")
+  );
+  console.log("");
+});
+
+// src/commands/milestones.ts
+import { Command as Command3 } from "commander";
+import chalk4 from "chalk";
+var milestonesCommand = new Command3("milestones").description("List local milestones").option("-v, --verbose", "Show full milestone details").action((opts) => {
+  const milestones = readJson(MILESTONES_FILE, []);
+  if (milestones.length === 0) {
+    console.log(info("No milestones recorded yet."));
+    return;
+  }
+  console.log(header(`Milestones (${milestones.length})`));
+  for (const m of milestones) {
+    const status = m.published ? chalk4.green("published") : chalk4.yellow("local");
+    console.log(
+      `
+  ${chalk4.bold(m.title)}  ${status}`
+    );
+    console.log(
+      table([
+        ["Category", m.category],
+        ["Complexity", m.complexity],
+        ["Duration", formatDuration(m.duration_minutes * 60)],
+        ["Date", m.created_at.slice(0, 10)]
+      ])
+    );
+    if (opts.verbose) {
+      console.log(
+        table([
+          ["ID", chalk4.dim(m.id)],
+          ["Session", chalk4.dim(m.session_id)],
+          ["Client", m.client],
+          ["Languages", m.languages.join(", ") || "none"],
+          ["Chain hash", chalk4.dim(m.chain_hash.slice(0, 16) + "...")],
+          ["Published at", m.published_at ?? "n/a"]
+        ])
+      );
+    }
+  }
+  console.log("");
+});
+
+// src/commands/config.ts
+import { Command as Command4 } from "commander";
+import chalk5 from "chalk";
+var configCommand = new Command4("config").description("View or update settings").option("--sync", "Enable auto-sync").option("--no-sync", "Disable auto-sync").option("--milestones", "Enable milestone tracking").option("--no-milestones", "Disable milestone tracking").action(() => {
+  let changed = false;
+  if (process.argv.includes("--no-sync")) {
+    updateConfig({ auto_sync: false });
+    console.log(success("Auto-sync disabled."));
+    changed = true;
+  } else if (process.argv.includes("--sync")) {
+    updateConfig({ auto_sync: true });
+    console.log(success("Auto-sync enabled."));
+    changed = true;
+  }
+  if (process.argv.includes("--no-milestones")) {
+    updateConfig({ milestone_tracking: false });
+    console.log(success("Milestone tracking disabled."));
+    changed = true;
+  } else if (process.argv.includes("--milestones")) {
+    updateConfig({ milestone_tracking: true });
+    console.log(success("Milestone tracking enabled."));
+    changed = true;
+  }
+  const config = getConfig();
+  if (!changed) {
+    console.log(header("Current Settings"));
+    console.log(
+      table([
+        ["Milestone tracking", config.milestone_tracking ? chalk5.green("on") : chalk5.red("off")],
+        ["Auto sync", config.auto_sync ? chalk5.green("on") : chalk5.red("off")],
+        ["Sync interval", `${config.sync_interval_hours}h`],
+        ["Last sync", config.last_sync_at ?? chalk5.dim("never")],
+        ["Logged in", config.auth ? chalk5.green(config.auth.user.email) : chalk5.dim("no")]
+      ])
+    );
+    console.log("");
+  }
+});
+
+// src/commands/export.ts
+import { Command as Command5 } from "commander";
+var exportCommand = new Command5("export").description("Export all local data as JSON to stdout").action(() => {
+  const config = getConfig();
+  const sessions = readJson(SESSIONS_FILE, []);
+  const milestones = readJson(MILESTONES_FILE, []);
+  const data = {
+    exported_at: (/* @__PURE__ */ new Date()).toISOString(),
+    config,
+    sessions,
+    milestones
+  };
+  process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+});
+
+// src/commands/purge.ts
+import { Command as Command6 } from "commander";
+import { existsSync as existsSync3, rmSync } from "fs";
+import { createInterface } from "readline";
+function confirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === "yes");
+    });
+  });
+}
+var purgeCommand = new Command6("purge").description("Delete ALL local useai data").option("-y, --yes", "Skip confirmation").action(async (opts) => {
+  if (!existsSync3(USEAI_DIR)) {
+    console.log(info("No useai data directory found. Nothing to purge."));
+    return;
+  }
+  if (!opts.yes) {
+    console.log(error(`This will permanently delete all data in ${USEAI_DIR}`));
+    const confirmed = await confirm('  Type "yes" to confirm: ');
+    if (!confirmed) {
+      console.log(info("Purge cancelled."));
+      return;
+    }
+  }
+  rmSync(USEAI_DIR, { recursive: true, force: true });
+  console.log(success("All local useai data has been deleted."));
+});
+
+// src/commands/setup.ts
+import { Command as Command7 } from "commander";
+import { checkbox } from "@inquirer/prompts";
+import chalk6 from "chalk";
+
+// src/services/tools.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname, join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+var MCP_ENTRY = {
+  command: "npx",
+  args: ["-y", "@devness/useai"]
+};
+var home = homedir2();
+function hasBinary(name) {
+  try {
+    execSync(`which ${name}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readJsonFile(path) {
+  if (!existsSync4(path)) return {};
+  try {
+    const raw = readFileSync2(path, "utf-8").trim();
+    if (!raw) return {};
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function writeJsonFile(path, data) {
+  mkdirSync2(dirname(path), { recursive: true });
+  writeFileSync2(path, JSON.stringify(data, null, 2) + "\n");
+}
+function isConfiguredStandard(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["mcpServers"];
+  return !!servers?.["useai"];
+}
+function installStandard(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["mcpServers"] ?? {};
+  servers["useai"] = { ...MCP_ENTRY };
+  config["mcpServers"] = servers;
+  writeJsonFile(configPath, config);
+}
+function removeStandard(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["mcpServers"];
+  if (servers) {
+    delete servers["useai"];
+    if (Object.keys(servers).length === 0) {
+      delete config["mcpServers"];
+    }
+    writeJsonFile(configPath, config);
+  }
+}
+function isConfiguredVscode(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["servers"];
+  return !!servers?.["useai"];
+}
+function installVscode(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["servers"] ?? {};
+  servers["useai"] = { command: MCP_ENTRY.command, args: MCP_ENTRY.args };
+  config["servers"] = servers;
+  writeJsonFile(configPath, config);
+}
+function removeVscode(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["servers"];
+  if (servers) {
+    delete servers["useai"];
+    if (Object.keys(servers).length === 0) {
+      delete config["servers"];
+    }
+    writeJsonFile(configPath, config);
+  }
+}
+function isConfiguredZed(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["context_servers"];
+  return !!servers?.["useai"];
+}
+function installZed(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["context_servers"] ?? {};
+  servers["useai"] = {
+    command: { path: MCP_ENTRY.command, args: MCP_ENTRY.args },
+    settings: {}
+  };
+  config["context_servers"] = servers;
+  writeJsonFile(configPath, config);
+}
+function removeZed(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["context_servers"];
+  if (servers) {
+    delete servers["useai"];
+    if (Object.keys(servers).length === 0) {
+      delete config["context_servers"];
+    }
+    writeJsonFile(configPath, config);
+  }
+}
+function readTomlFile(path) {
+  if (!existsSync4(path)) return {};
+  try {
+    const raw = readFileSync2(path, "utf-8").trim();
+    if (!raw) return {};
+    return parseToml(raw);
+  } catch {
+    return {};
+  }
+}
+function writeTomlFile(path, data) {
+  mkdirSync2(dirname(path), { recursive: true });
+  writeFileSync2(path, stringifyToml(data) + "\n");
+}
+function isConfiguredToml(configPath) {
+  const config = readTomlFile(configPath);
+  const servers = config["mcp_servers"];
+  return !!servers?.["useai"];
+}
+function installToml(configPath) {
+  const config = readTomlFile(configPath);
+  const servers = config["mcp_servers"] ?? {};
+  servers["useai"] = { command: MCP_ENTRY.command, args: MCP_ENTRY.args };
+  config["mcp_servers"] = servers;
+  writeTomlFile(configPath, config);
+}
+function removeToml(configPath) {
+  const config = readTomlFile(configPath);
+  const servers = config["mcp_servers"];
+  if (servers) {
+    delete servers["useai"];
+    if (Object.keys(servers).length === 0) {
+      delete config["mcp_servers"];
+    }
+    writeTomlFile(configPath, config);
+  }
+}
+function readYamlFile(path) {
+  if (!existsSync4(path)) return {};
+  try {
+    const raw = readFileSync2(path, "utf-8").trim();
+    if (!raw) return {};
+    return parseYaml(raw) ?? {};
+  } catch {
+    return {};
+  }
+}
+function writeYamlFile(path, data) {
+  mkdirSync2(dirname(path), { recursive: true });
+  writeFileSync2(path, stringifyYaml(data));
+}
+function isConfiguredYaml(configPath) {
+  const config = readYamlFile(configPath);
+  const extensions = config["extensions"];
+  return !!extensions?.["useai"];
+}
+function installYaml(configPath) {
+  const config = readYamlFile(configPath);
+  const extensions = config["extensions"] ?? {};
+  extensions["useai"] = {
+    name: "useai",
+    cmd: MCP_ENTRY.command,
+    args: MCP_ENTRY.args,
+    enabled: true,
+    type: "stdio"
+  };
+  config["extensions"] = extensions;
+  writeYamlFile(configPath, config);
+}
+function removeYaml(configPath) {
+  const config = readYamlFile(configPath);
+  const extensions = config["extensions"];
+  if (extensions) {
+    delete extensions["useai"];
+    if (Object.keys(extensions).length === 0) {
+      delete config["extensions"];
+    }
+    writeYamlFile(configPath, config);
+  }
+}
+var formatHandlers = {
+  standard: { isConfigured: isConfiguredStandard, install: installStandard, remove: removeStandard },
+  vscode: { isConfigured: isConfiguredVscode, install: installVscode, remove: removeVscode },
+  zed: { isConfigured: isConfiguredZed, install: installZed, remove: removeZed },
+  toml: { isConfigured: isConfiguredToml, install: installToml, remove: removeToml },
+  yaml: { isConfigured: isConfiguredYaml, install: installYaml, remove: removeYaml }
+};
+function createTool(def) {
+  const handler = formatHandlers[def.configFormat];
+  return {
+    id: def.id,
+    name: def.name,
+    configFormat: def.configFormat,
+    getConfigPath: () => def.configPath,
+    detect: def.detect,
+    isConfigured: () => handler.isConfigured(def.configPath),
+    install: () => handler.install(def.configPath),
+    remove: () => handler.remove(def.configPath)
+  };
+}
+var appSupport = join2(home, "Library", "Application Support");
+function matchesTool(tool, query) {
+  const q = query.toLowerCase().replace(/[\s-_]+/g, "");
+  const id = tool.id.toLowerCase().replace(/[\s-_]+/g, "");
+  const name = tool.name.toLowerCase().replace(/[\s-_]+/g, "");
+  return id === q || name === q || id.includes(q) || name.includes(q);
+}
+function resolveTools(names) {
+  const matched = [];
+  const unmatched = [];
+  for (const name of names) {
+    const found = AI_TOOLS.filter((t) => matchesTool(t, name));
+    if (found.length > 0) {
+      for (const f of found) {
+        if (!matched.includes(f)) matched.push(f);
+      }
+    } else {
+      unmatched.push(name);
+    }
+  }
+  return { matched, unmatched };
+}
+var AI_TOOLS = [
+  createTool({
+    id: "claude-code",
+    name: "Claude Code",
+    configFormat: "standard",
+    configPath: join2(home, ".claude.json"),
+    detect: () => hasBinary("claude") || existsSync4(join2(home, ".claude.json"))
+  }),
+  createTool({
+    id: "claude-desktop",
+    name: "Claude Desktop",
+    configFormat: "standard",
+    configPath: join2(appSupport, "Claude", "claude_desktop_config.json"),
+    detect: () => existsSync4(join2(appSupport, "Claude")) || existsSync4("/Applications/Claude.app")
+  }),
+  createTool({
+    id: "cursor",
+    name: "Cursor",
+    configFormat: "standard",
+    configPath: join2(home, ".cursor", "mcp.json"),
+    detect: () => existsSync4(join2(home, ".cursor"))
+  }),
+  createTool({
+    id: "windsurf",
+    name: "Windsurf",
+    configFormat: "standard",
+    configPath: join2(home, ".codeium", "windsurf", "mcp_config.json"),
+    detect: () => existsSync4(join2(home, ".codeium", "windsurf"))
+  }),
+  createTool({
+    id: "vscode",
+    name: "VS Code",
+    configFormat: "vscode",
+    configPath: join2(appSupport, "Code", "User", "mcp.json"),
+    detect: () => existsSync4(join2(appSupport, "Code"))
+  }),
+  createTool({
+    id: "vscode-insiders",
+    name: "VS Code Insiders",
+    configFormat: "vscode",
+    configPath: join2(appSupport, "Code - Insiders", "User", "mcp.json"),
+    detect: () => existsSync4(join2(appSupport, "Code - Insiders"))
+  }),
+  createTool({
+    id: "gemini-cli",
+    name: "Gemini CLI",
+    configFormat: "standard",
+    configPath: join2(home, ".gemini", "settings.json"),
+    detect: () => hasBinary("gemini")
+  }),
+  createTool({
+    id: "zed",
+    name: "Zed",
+    configFormat: "zed",
+    configPath: join2(appSupport, "Zed", "settings.json"),
+    detect: () => existsSync4(join2(appSupport, "Zed"))
+  }),
+  createTool({
+    id: "cline",
+    name: "Cline",
+    configFormat: "standard",
+    configPath: join2(
+      appSupport,
+      "Code",
+      "User",
+      "globalStorage",
+      "saoudrizwan.claude-dev",
+      "settings",
+      "cline_mcp_settings.json"
+    ),
+    detect: () => existsSync4(
+      join2(appSupport, "Code", "User", "globalStorage", "saoudrizwan.claude-dev")
+    )
+  }),
+  createTool({
+    id: "roo-code",
+    name: "Roo Code",
+    configFormat: "standard",
+    configPath: join2(
+      appSupport,
+      "Code",
+      "User",
+      "globalStorage",
+      "rooveterinaryinc.roo-cline",
+      "settings",
+      "cline_mcp_settings.json"
+    ),
+    detect: () => existsSync4(
+      join2(appSupport, "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline")
+    )
+  }),
+  createTool({
+    id: "amazon-q-cli",
+    name: "Amazon Q CLI",
+    configFormat: "standard",
+    configPath: join2(home, ".aws", "amazonq", "mcp.json"),
+    detect: () => hasBinary("q") || existsSync4(join2(home, ".aws", "amazonq"))
+  }),
+  createTool({
+    id: "amazon-q-ide",
+    name: "Amazon Q IDE",
+    configFormat: "standard",
+    configPath: join2(home, ".aws", "amazonq", "default.json"),
+    detect: () => existsSync4(join2(home, ".amazonq")) || existsSync4(join2(home, ".aws", "amazonq"))
+  }),
+  createTool({
+    id: "codex",
+    name: "Codex",
+    configFormat: "toml",
+    configPath: join2(home, ".codex", "config.toml"),
+    detect: () => hasBinary("codex") || existsSync4(join2(home, ".codex")) || existsSync4("/Applications/Codex.app")
+  }),
+  createTool({
+    id: "goose",
+    name: "Goose",
+    configFormat: "yaml",
+    configPath: join2(home, ".config", "goose", "config.yaml"),
+    detect: () => existsSync4(join2(home, ".config", "goose"))
+  }),
+  createTool({
+    id: "opencode",
+    name: "OpenCode",
+    configFormat: "standard",
+    configPath: join2(home, ".config", "opencode", "opencode.json"),
+    detect: () => hasBinary("opencode") || existsSync4(join2(home, ".config", "opencode"))
+  }),
+  createTool({
+    id: "junie",
+    name: "Junie",
+    configFormat: "standard",
+    configPath: join2(home, ".junie", "mcp", "mcp.json"),
+    detect: () => existsSync4(join2(home, ".junie"))
+  })
+];
+
+// src/commands/setup.ts
+function shortenPath(p) {
+  const home2 = process.env["HOME"] ?? "";
+  return home2 && p.startsWith(home2) ? p.replace(home2, "~") : p;
+}
+function showStatus(tools) {
+  console.log(header("AI Tool MCP Status"));
+  const rows = [];
+  const nameWidth = Math.max(...tools.map((t) => t.name.length));
+  const statusWidth = 16;
+  for (const tool of tools) {
+    const detected = tool.detect();
+    const name = tool.name.padEnd(nameWidth);
+    if (!detected) {
+      rows.push(`  ${chalk6.dim(name)}  ${chalk6.dim("\u2014 Not found".padEnd(statusWidth))}`);
+    } else if (tool.isConfigured()) {
+      rows.push(
+        `  ${name}  ${chalk6.green("\u2713 Configured".padEnd(statusWidth))}  ${chalk6.dim(shortenPath(tool.getConfigPath()))}`
+      );
+    } else {
+      rows.push(
+        `  ${name}  ${chalk6.yellow("\u2717 Not set up".padEnd(statusWidth))}  ${chalk6.dim(shortenPath(tool.getConfigPath()))}`
+      );
+    }
+  }
+  console.log(rows.join("\n"));
+  console.log();
+}
+async function installFlow(tools, autoYes, explicit) {
+  if (explicit) {
+    const toInstall2 = tools.filter((t) => !t.isConfigured());
+    const alreadyDone = tools.filter((t) => t.isConfigured());
+    for (const tool of alreadyDone) {
+      console.log(info(`${tool.name} is already configured.`));
+    }
+    if (toInstall2.length === 0) return;
+    console.log();
+    for (const tool of toInstall2) {
+      try {
+        tool.install();
+        console.log(success(`\u2713 ${tool.name.padEnd(18)} \u2192 ${chalk6.dim(shortenPath(tool.getConfigPath()))}`));
+      } catch (err) {
+        console.log(error(`\u2717 ${tool.name.padEnd(18)} \u2014 ${err.message}`));
+      }
+    }
+    console.log();
+    return;
+  }
+  console.log(info("Scanning for AI tools...\n"));
+  const detected = tools.filter((t) => t.detect());
+  if (detected.length === 0) {
+    console.log(error("No AI tools detected on this machine."));
+    return;
+  }
+  const alreadyConfigured = detected.filter((t) => t.isConfigured());
+  const unconfigured = detected.filter((t) => !t.isConfigured());
+  console.log(`  Found ${chalk6.bold(String(detected.length))} AI tool${detected.length === 1 ? "" : "s"} on this machine:
+`);
+  for (const tool of alreadyConfigured) {
+    console.log(chalk6.green(`  \u2705 ${tool.name}`) + chalk6.dim("  (already configured)"));
+  }
+  for (const tool of unconfigured) {
+    console.log(chalk6.dim(`  \u2610  ${tool.name}`));
+  }
+  console.log();
+  if (unconfigured.length === 0) {
+    console.log(success("All detected tools are already configured."));
+    return;
+  }
+  let toInstall;
+  if (autoYes) {
+    toInstall = unconfigured;
+  } else {
+    const selected = await checkbox({
+      message: "Select tools to configure:",
+      choices: unconfigured.map((t) => ({
+        name: t.name,
+        value: t.id,
+        checked: true
+      }))
+    });
+    toInstall = unconfigured.filter((t) => selected.includes(t.id));
+  }
+  if (toInstall.length === 0) {
+    console.log(info("No tools selected."));
+    return;
+  }
+  console.log(`
+  Configuring ${toInstall.length} tool${toInstall.length === 1 ? "" : "s"}...
+`);
+  for (const tool of toInstall) {
+    try {
+      tool.install();
+      console.log(success(`\u2713 ${tool.name.padEnd(18)} \u2192 ${chalk6.dim(shortenPath(tool.getConfigPath()))}`));
+    } catch (err) {
+      console.log(error(`\u2717 ${tool.name.padEnd(18)} \u2014 ${err.message}`));
+    }
+  }
+  console.log(`
+  Done! useai MCP server configured in ${chalk6.bold(String(toInstall.length))} tool${toInstall.length === 1 ? "" : "s"}.
+`);
+}
+async function removeFlow(tools, autoYes, explicit) {
+  if (explicit) {
+    const toRemove2 = tools.filter((t) => {
+      try {
+        return t.isConfigured();
+      } catch {
+        return false;
+      }
+    });
+    const notConfigured = tools.filter((t) => {
+      try {
+        return !t.isConfigured();
+      } catch {
+        return true;
+      }
+    });
+    for (const tool of notConfigured) {
+      console.log(info(`${tool.name} is not configured \u2014 skipping.`));
+    }
+    if (toRemove2.length === 0) return;
+    console.log();
+    for (const tool of toRemove2) {
+      try {
+        tool.remove();
+        console.log(success(`\u2713 Removed from ${tool.name}`));
+      } catch (err) {
+        console.log(error(`\u2717 ${tool.name} \u2014 ${err.message}`));
+      }
+    }
+    console.log();
+    return;
+  }
+  const configured = tools.filter((t) => {
+    try {
+      return t.isConfigured();
+    } catch {
+      return false;
+    }
+  });
+  if (configured.length === 0) {
+    console.log(info("useai is not configured in any AI tools."));
+    return;
+  }
+  console.log(`
+  Found useai configured in ${chalk6.bold(String(configured.length))} tool${configured.length === 1 ? "" : "s"}:
+`);
+  let toRemove;
+  if (autoYes) {
+    toRemove = configured;
+  } else {
+    const selected = await checkbox({
+      message: "Select tools to remove useai from:",
+      choices: configured.map((t) => ({
+        name: t.name,
+        value: t.id,
+        checked: true
+      }))
+    });
+    toRemove = configured.filter((t) => selected.includes(t.id));
+  }
+  if (toRemove.length === 0) {
+    console.log(info("No tools selected."));
+    return;
+  }
+  console.log(`
+  Removing from ${toRemove.length} tool${toRemove.length === 1 ? "" : "s"}...
+`);
+  for (const tool of toRemove) {
+    try {
+      tool.remove();
+      console.log(success(`\u2713 Removed from ${tool.name}`));
+    } catch (err) {
+      console.log(error(`\u2717 ${tool.name} \u2014 ${err.message}`));
+    }
+  }
+  console.log(`
+  Done! useai removed from ${chalk6.bold(String(toRemove.length))} tool${toRemove.length === 1 ? "" : "s"}.
+`);
+}
+var mcpCommand = new Command7("mcp").description("Configure useai MCP server in your AI tools").argument("[tools...]", "Specific tool names (e.g. codex cursor vscode)").option("--remove", "Remove useai from configured tools").option("--status", "Show configuration status without modifying").option("-y, --yes", "Skip confirmation, auto-select all detected tools").action(async (toolNames, opts) => {
+  const explicit = toolNames.length > 0;
+  let tools = AI_TOOLS;
+  if (explicit) {
+    const { matched, unmatched } = resolveTools(toolNames);
+    if (unmatched.length > 0) {
+      console.log(error(`Unknown tool${unmatched.length === 1 ? "" : "s"}: ${unmatched.join(", ")}`));
+      console.log(info(`Available: ${AI_TOOLS.map((t) => t.id).join(", ")}`));
+      return;
+    }
+    tools = matched;
+  }
+  if (opts.status) {
+    showStatus(tools);
+  } else if (opts.remove) {
+    await removeFlow(tools, !!opts.yes, explicit);
+  } else {
+    await installFlow(tools, !!opts.yes, explicit);
+  }
+});
+
+// src/index.ts
+var program = new Command8();
+program.name("useai").description("useai.dev \u2014 Track your AI-assisted development workflow").version(VERSION);
+program.addCommand(statsCommand);
+program.addCommand(statusCommand);
+program.addCommand(milestonesCommand);
+program.addCommand(configCommand);
+program.addCommand(exportCommand);
+program.addCommand(purgeCommand);
+program.addCommand(mcpCommand);
+program.parse();

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@devness/useai-cli",
+  "version": "0.3.0",
+  "description": "CLI tool for useai.dev — stats, sync, publish your AI development workflow",
+  "author": "nabeelkausari",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "useai": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@inquirer/prompts": "^8.2.1",
+    "chalk": "^5.4.1",
+    "commander": "^12.1.0",
+    "smol-toml": "^1.6.0",
+    "yaml": "^2.8.2",
+    "@useai/shared": "0.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.4",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nabeelkausari/useai"
+  },
+  "homepage": "https://useai.dev",
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsc --watch",
+    "bundle": "tsup src/index.ts --format esm --target node18 --no-splitting",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}