@piut/cli 1.1.0 → 2.0.0

package/README.md

@@ -11,7 +11,8 @@ pıut does three things that build on each other:
 ## Quick Start
 
 ```bash
-npx @piut/cli
+npm install -g @piut/cli
+piut
 ```
 
 The CLI does everything in one interactive flow:
@@ -43,33 +44,37 @@ See [piut.com/docs](https://piut.com/docs#add-to-ai) for setup guides for 14+ AI
 
 ## CLI
 
-Install globally or run with `npx`:
+Install globally, then use the `piut` command:
 
 ```bash
+npm install -g @piut/cli
+
 # Setup & Configuration
-npx @piut/cli              # Interactive setup: MCP + skill.md + cloud backup
-npx @piut/cli status       # Show which tools are connected
-npx @piut/cli remove       # Remove pıut from selected tools
+piut                       # Interactive setup: MCP + skill.md + cloud backup
+piut status                # Show which tools are connected
+piut remove                # Remove pıut from selected tools
 
 # Cloud Backup
-npx @piut/cli sync         # Show backup status for current workspace
-npx @piut/cli sync --install  # Scan workspace, detect files, upload to cloud
-npx @piut/cli sync --push  # Push local changes to cloud
-npx @piut/cli sync --pull  # Pull cloud changes to local files
-npx @piut/cli sync --history   # Show version history for a file
-npx @piut/cli sync --diff  # Show diff between local and cloud
-npx @piut/cli sync --restore   # Restore files from cloud backup
+piut sync                  # Show backup status for current workspace
+piut sync --install        # Scan workspace, detect files, upload to cloud
+piut sync --push           # Push local changes to cloud
+piut sync --pull           # Pull cloud changes to local files
+piut sync --history        # Show version history for a file
+piut sync --diff           # Show diff between local and cloud
+piut sync --restore        # Restore files from cloud backup
 ```
 
 **Options:**
 
 ```bash
-npx @piut/cli --key pb_... # Pass API key non-interactively
-npx @piut/cli --tool cursor # Configure a single tool
-npx @piut/cli --skip-skill  # Skip skill.md file placement
-npx @piut/cli sync --install --yes  # Non-interactive backup setup
+piut --key pb_...          # Pass API key non-interactively
+piut --tool cursor         # Configure a single tool
+piut --skip-skill          # Skip skill.md file placement
+piut sync --install --yes  # Non-interactive backup setup
 ```
 
+You can also use `npx @piut/cli` without installing globally.
+
 **Supported tools:** Claude Code, Claude Desktop, Cursor, Windsurf, GitHub Copilot, Amazon Q, Zed
 
 ## The Three Features

package/dist/cli.js

@@ -22,6 +22,43 @@ async function validateKey(key) {
   }
   return res.json();
 }
+async function buildBrain(key, input) {
+  const res = await fetch(`${API_BASE}/api/cli/build-brain`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${key}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(input)
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    if (res.status === 429) {
+      throw new Error(body.error || "Rate limit exceeded (3 builds per day)");
+    }
+    throw new Error(body.error || `Build failed (HTTP ${res.status})`);
+  }
+  const data = await res.json();
+  return data.sections;
+}
+async function publishServer(key) {
+  const res = await fetch(`${API_BASE}/api/mcp/publish`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${key}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ published: true })
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    if (res.status === 402) {
+      throw new Error("REQUIRES_SUBSCRIPTION");
+    }
+    throw new Error(body.error || `Publish failed (HTTP ${res.status})`);
+  }
+  return res.json();
+}
 
 // src/lib/tools.ts
 import os from "os";
@@ -427,16 +464,283 @@ function isCommandAvailable(cmd) {
 }
 
 // src/commands/status.ts
+import fs5 from "fs";
+import path7 from "path";
+
+// src/lib/brain-scanner.ts
 import fs4 from "fs";
+import path6 from "path";
+import os3 from "os";
+var home2 = os3.homedir();
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  ".output",
+  ".Trash",
+  "Library",
+  ".cache",
+  ".npm",
+  ".yarn",
+  ".pnpm-store",
+  "Caches",
+  "Cache"
+]);
+var FULL_READ_FILES = /* @__PURE__ */ new Set([
+  "README.md",
+  "CLAUDE.md",
+  ".cursorrules",
+  ".windsurfrules",
+  "AGENTS.md",
+  "CONVENTIONS.md",
+  "MEMORY.md",
+  "SOUL.md",
+  "IDENTITY.md"
+]);
+var MAX_FILE_SIZE = 100 * 1024;
+var RECENT_DAYS = 30;
+function shouldSkipDir(name) {
+  if (name.startsWith(".") && name !== ".claude" && name !== ".cursor" && name !== ".windsurf" && name !== ".github" && name !== ".zed") {
+    return true;
+  }
+  return SKIP_DIRS.has(name);
+}
+function readFileSafe(filePath) {
+  try {
+    const stat = fs4.statSync(filePath);
+    if (stat.size > MAX_FILE_SIZE) return null;
+    if (!stat.isFile()) return null;
+    return fs4.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function getFolderTree(dir, depth = 0, maxDepth = 3) {
+  if (depth >= maxDepth) return [];
+  const entries = [];
+  try {
+    const items = fs4.readdirSync(dir, { withFileTypes: true });
+    for (const item of items) {
+      if (!item.isDirectory()) continue;
+      if (shouldSkipDir(item.name)) continue;
+      const indent = "  ".repeat(depth);
+      entries.push(`${indent}${item.name}/`);
+      entries.push(...getFolderTree(path6.join(dir, item.name), depth + 1, maxDepth));
+    }
+  } catch {
+  }
+  return entries;
+}
+function detectProjects(scanDirs) {
+  const projects = [];
+  for (const dir of scanDirs) {
+    try {
+      const items = fs4.readdirSync(dir, { withFileTypes: true });
+      for (const item of items) {
+        if (!item.isDirectory()) continue;
+        if (shouldSkipDir(item.name)) continue;
+        const projectPath = path6.join(dir, item.name);
+        const hasGit = fs4.existsSync(path6.join(projectPath, ".git"));
+        const hasPkgJson = fs4.existsSync(path6.join(projectPath, "package.json"));
+        const hasCargoToml = fs4.existsSync(path6.join(projectPath, "Cargo.toml"));
+        const hasPyproject = fs4.existsSync(path6.join(projectPath, "pyproject.toml"));
+        const hasGoMod = fs4.existsSync(path6.join(projectPath, "go.mod"));
+        if (!hasGit && !hasPkgJson && !hasCargoToml && !hasPyproject && !hasGoMod) continue;
+        let description = "";
+        if (hasPkgJson) {
+          try {
+            const pkg = JSON.parse(fs4.readFileSync(path6.join(projectPath, "package.json"), "utf-8"));
+            description = pkg.description || "";
+          } catch {
+          }
+        }
+        const readmePath = path6.join(projectPath, "README.md");
+        if (!description && fs4.existsSync(readmePath)) {
+          const content = readFileSafe(readmePath);
+          if (content) {
+            const lines = content.split("\n");
+            let foundHeading = false;
+            for (const line of lines) {
+              if (line.startsWith("#")) {
+                foundHeading = true;
+                continue;
+              }
+              if (foundHeading && line.trim()) {
+                description = line.trim().slice(0, 200);
+                break;
+              }
+            }
+          }
+        }
+        projects.push({
+          name: item.name,
+          path: projectPath,
+          description,
+          hasClaudeMd: fs4.existsSync(path6.join(projectPath, "CLAUDE.md")),
+          hasCursorRules: fs4.existsSync(path6.join(projectPath, ".cursorrules")) || fs4.existsSync(path6.join(projectPath, ".cursor", "rules")),
+          hasWindsurfRules: fs4.existsSync(path6.join(projectPath, ".windsurfrules")) || fs4.existsSync(path6.join(projectPath, ".windsurf", "rules")),
+          hasCopilotInstructions: fs4.existsSync(path6.join(projectPath, ".github", "copilot-instructions.md")),
+          hasConventionsMd: fs4.existsSync(path6.join(projectPath, "CONVENTIONS.md")),
+          hasZedRules: fs4.existsSync(path6.join(projectPath, ".zed", "rules.md"))
+        });
+      }
+    } catch {
+    }
+  }
+  return projects;
+}
+function collectConfigFiles(projects) {
+  const configs = [];
+  const globalPaths = [
+    path6.join(home2, ".claude", "MEMORY.md"),
+    path6.join(home2, ".claude", "CLAUDE.md"),
+    path6.join(home2, ".openclaw", "workspace", "SOUL.md"),
+    path6.join(home2, ".openclaw", "workspace", "MEMORY.md")
+  ];
+  for (const gp of globalPaths) {
+    const content = readFileSafe(gp);
+    if (content && content.trim()) {
+      configs.push({ name: `~/${path6.relative(home2, gp)}`, content });
+    }
+  }
+  for (const project of projects) {
+    for (const fileName of FULL_READ_FILES) {
+      const filePath = path6.join(project.path, fileName);
+      const content = readFileSafe(filePath);
+      if (content && content.trim()) {
+        configs.push({ name: `${project.name}/${fileName}`, content });
+      }
+    }
+    const pkgPath = path6.join(project.path, "package.json");
+    const pkgContent = readFileSafe(pkgPath);
+    if (pkgContent) {
+      try {
+        const pkg = JSON.parse(pkgContent);
+        const summary = JSON.stringify({ name: pkg.name, description: pkg.description }, null, 2);
+        configs.push({ name: `${project.name}/package.json`, content: summary });
+      } catch {
+      }
+    }
+  }
+  return configs;
+}
+function collectRecentDocs(projects) {
+  const docs = [];
+  const cutoff = Date.now() - RECENT_DAYS * 24 * 60 * 60 * 1e3;
+  const seen = /* @__PURE__ */ new Set();
+  for (const project of projects) {
+    try {
+      const items = fs4.readdirSync(project.path, { withFileTypes: true });
+      for (const item of items) {
+        if (!item.isFile()) continue;
+        if (!item.name.endsWith(".md")) continue;
+        if (FULL_READ_FILES.has(item.name)) continue;
+        if (item.name.startsWith(".")) continue;
+        const filePath = path6.join(project.path, item.name);
+        if (seen.has(filePath)) continue;
+        seen.add(filePath);
+        try {
+          const stat = fs4.statSync(filePath);
+          if (stat.mtimeMs < cutoff) continue;
+          if (stat.size > MAX_FILE_SIZE) continue;
+          const content = fs4.readFileSync(filePath, "utf-8");
+          if (content.trim()) {
+            docs.push({ name: `${project.name}/${item.name}`, content });
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return docs.slice(0, 20);
+}
+function getDefaultScanDirs() {
+  const dirs = [];
+  const candidates = [
+    path6.join(home2, "Projects"),
+    path6.join(home2, "projects"),
+    path6.join(home2, "Developer"),
+    path6.join(home2, "dev"),
+    path6.join(home2, "Code"),
+    path6.join(home2, "code"),
+    path6.join(home2, "src"),
+    path6.join(home2, "repos"),
+    path6.join(home2, "workspace"),
+    path6.join(home2, "Workspace"),
+    path6.join(home2, "Documents"),
+    path6.join(home2, "Desktop")
+  ];
+  for (const dir of candidates) {
+    if (fs4.existsSync(dir) && fs4.statSync(dir).isDirectory()) {
+      dirs.push(dir);
+    }
+  }
+  if (dirs.length === 0) {
+    dirs.push(home2);
+  }
+  return dirs;
+}
+function scanForBrain(folders) {
+  const scanDirs = folders || getDefaultScanDirs();
+  const folderTree = [];
+  for (const dir of scanDirs) {
+    folderTree.push(`${path6.basename(dir)}/`);
+    folderTree.push(...getFolderTree(dir, 1));
+  }
+  const projects = detectProjects(scanDirs);
+  const configFiles = collectConfigFiles(projects);
+  const recentDocuments = collectRecentDocs(projects);
+  return {
+    summary: {
+      folders: folderTree,
+      projects: projects.map((p) => ({
+        name: p.name,
+        path: p.path.replace(home2, "~"),
+        description: p.description
+      })),
+      configFiles,
+      recentDocuments
+    }
+  };
+}
+function scanForProjects(folders) {
+  const scanDirs = folders || getDefaultScanDirs();
+  return detectProjects(scanDirs);
+}
+
+// src/commands/status.ts
+var PIUT_FILES = [
+  "CLAUDE.md",
+  ".cursor/rules/piut.mdc",
+  ".windsurf/rules/piut.md",
+  ".github/copilot-instructions.md",
+  "CONVENTIONS.md",
+  ".zed/rules.md"
+];
+function hasPiutReference(filePath) {
+  try {
+    const content = fs5.readFileSync(filePath, "utf-8");
+    return content.includes("p\u0131ut Context") || content.includes("piut Context");
+  } catch {
+    return false;
+  }
+}
 function statusCommand() {
   banner();
-  console.log("  AI tool configuration status:");
+  console.log("  AI tool configuration:");
   console.log();
   let foundAny = false;
   for (const tool of TOOLS) {
     const paths = resolveConfigPaths(tool.configPaths);
     for (const configPath of paths) {
-      if (!fs4.existsSync(configPath)) continue;
+      if (!fs5.existsSync(configPath)) continue;
       foundAny = true;
       const configured = isPiutConfigured(configPath, tool.configKey);
       if (configured) {
@@ -449,13 +753,38 @@ function statusCommand() {
   }
   if (!foundAny) {
     console.log(warning("  No supported AI tools detected."));
-    console.log(dim("  Supported: Claude Code, Claude Desktop, Cursor, Windsurf, GitHub Copilot, Amazon Q, Zed"));
+    console.log(dim("  Run ") + brand("piut setup") + dim(" to configure your AI tools."));
+  }
+  console.log();
+  console.log("  Connected projects:");
+  console.log();
+  const projects = scanForProjects();
+  let connectedCount = 0;
+  for (const project of projects) {
+    const connectedFiles = [];
+    for (const file of PIUT_FILES) {
+      const absPath = path7.join(project.path, file);
+      if (fs5.existsSync(absPath) && hasPiutReference(absPath)) {
+        connectedFiles.push(file);
+      }
+    }
+    if (connectedFiles.length > 0) {
+      connectedCount++;
+      console.log(success(`  \u2714 ${project.name}`) + dim(` (${connectedFiles.join(", ")})`));
+    }
+  }
+  if (connectedCount === 0) {
+    console.log(dim("  No projects connected."));
+    console.log(dim("  Run ") + brand("piut connect") + dim(" to add brain references to your projects."));
+  } else {
+    console.log();
+    console.log(dim(`  ${connectedCount} project(s) connected to your brain.`));
   }
   console.log();
 }
 
 // src/commands/remove.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import { checkbox as checkbox2, confirm as confirm2 } from "@inquirer/prompts";
 async function removeCommand() {
   banner();
@@ -463,7 +792,7 @@ async function removeCommand() {
   for (const tool of TOOLS) {
     const paths = resolveConfigPaths(tool.configPaths);
     for (const configPath of paths) {
-      if (fs5.existsSync(configPath) && isPiutConfigured(configPath, tool.configKey)) {
+      if (fs6.existsSync(configPath) && isPiutConfigured(configPath, tool.configKey)) {
         configured.push({ tool, configPath });
         break;
       }
@@ -506,15 +835,15 @@ async function removeCommand() {
 }
 
 // src/commands/sync.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import crypto2 from "crypto";
 import { password as password2, confirm as confirm3, checkbox as checkbox3, select } from "@inquirer/prompts";
 import chalk3 from "chalk";
 
 // src/lib/scanner.ts
-import fs6 from "fs";
-import path6 from "path";
-import os3 from "os";
+import fs7 from "fs";
+import path8 from "path";
+import os4 from "os";
 var KNOWN_FILES = [
   "CLAUDE.md",
   ".claude/MEMORY.md",
@@ -543,7 +872,7 @@ function detectInstalledTools() {
   for (const tool of TOOLS) {
     const paths = resolveConfigPaths(tool.configPaths);
     for (const configPath of paths) {
-      if (fs6.existsSync(configPath) || fs6.existsSync(path6.dirname(configPath))) {
+      if (fs7.existsSync(configPath) || fs7.existsSync(path8.dirname(configPath))) {
         installed.push({ name: tool.name, id: tool.id });
         break;
       }
@@ -572,22 +901,22 @@ function scanDirectory(dir, patterns) {
   for (const pattern of patterns) {
     const parts = pattern.split("/");
     if (parts.length === 1) {
-      const filePath = path6.join(dir, pattern);
-      if (fs6.existsSync(filePath) && fs6.statSync(filePath).isFile()) {
+      const filePath = path8.join(dir, pattern);
+      if (fs7.existsSync(filePath) && fs7.statSync(filePath).isFile()) {
         found.push(filePath);
       }
     } else {
       const lastPart = parts[parts.length - 1];
       const dirPart = parts.slice(0, -1).join("/");
-      const fullDir = path6.join(dir, dirPart);
+      const fullDir = path8.join(dir, dirPart);
       if (lastPart.includes("*")) {
-        if (fs6.existsSync(fullDir) && fs6.statSync(fullDir).isDirectory()) {
+        if (fs7.existsSync(fullDir) && fs7.statSync(fullDir).isDirectory()) {
           try {
-            const entries = fs6.readdirSync(fullDir);
+            const entries = fs7.readdirSync(fullDir);
             for (const entry of entries) {
               if (matchesGlob(entry, lastPart)) {
-                const fullPath = path6.join(fullDir, entry);
-                if (fs6.statSync(fullPath).isFile()) {
+                const fullPath = path8.join(fullDir, entry);
+                if (fs7.statSync(fullPath).isFile()) {
                   found.push(fullPath);
                 }
               }
@@ -596,8 +925,8 @@ function scanDirectory(dir, patterns) {
           }
         }
       } else {
-        const filePath = path6.join(dir, pattern);
-        if (fs6.existsSync(filePath) && fs6.statSync(filePath).isFile()) {
+        const filePath = path8.join(dir, pattern);
+        if (fs7.existsSync(filePath) && fs7.statSync(filePath).isFile()) {
           found.push(filePath);
         }
       }
@@ -606,18 +935,18 @@ function scanDirectory(dir, patterns) {
   return found;
 }
 function scanForFiles(workspaceDirs) {
-  const home2 = os3.homedir();
+  const home3 = os4.homedir();
   const files = [];
   const seen = /* @__PURE__ */ new Set();
   for (const globalPath of GLOBAL_FILES) {
     const absPath = expandPath(globalPath);
-    if (fs6.existsSync(absPath) && fs6.statSync(absPath).isFile()) {
+    if (fs7.existsSync(absPath) && fs7.statSync(absPath).isFile()) {
       if (seen.has(absPath)) continue;
       seen.add(absPath);
       files.push({
         absolutePath: absPath,
         displayPath: globalPath,
-        sizeBytes: fs6.statSync(absPath).size,
+        sizeBytes: fs7.statSync(absPath).size,
         category: "Global",
         type: "global",
         projectName: "Global"
@@ -626,18 +955,18 @@ function scanForFiles(workspaceDirs) {
   }
   const dirs = workspaceDirs || [process.cwd()];
   for (const dir of dirs) {
-    const absDir = path6.resolve(dir);
-    if (!fs6.existsSync(absDir)) continue;
+    const absDir = path8.resolve(dir);
+    if (!fs7.existsSync(absDir)) continue;
     const foundPaths = scanDirectory(absDir, KNOWN_FILES);
     for (const filePath of foundPaths) {
       if (seen.has(filePath)) continue;
       seen.add(filePath);
-      const relativePath = path6.relative(absDir, filePath);
-      const projectName = path6.basename(absDir);
+      const relativePath = path8.relative(absDir, filePath);
+      const projectName = path8.basename(absDir);
       files.push({
         absolutePath: filePath,
-        displayPath: path6.relative(home2, filePath).startsWith("..") ? filePath : "~/" + path6.relative(home2, filePath),
-        sizeBytes: fs6.statSync(filePath).size,
+        displayPath: path8.relative(home3, filePath).startsWith("..") ? filePath : "~/" + path8.relative(home3, filePath),
+        sizeBytes: fs7.statSync(filePath).size,
         category: categorizeFile(filePath),
         type: "project",
         projectName
@@ -730,14 +1059,14 @@ async function resolveConflict(apiKey, fileId, resolution, localContent, deviceI
 }
 
 // src/lib/sync-config.ts
-import fs7 from "fs";
-import path7 from "path";
-import os4 from "os";
+import fs8 from "fs";
+import path9 from "path";
+import os5 from "os";
 import crypto from "crypto";
-var CONFIG_DIR = path7.join(os4.homedir(), ".piut");
-var CONFIG_FILE = path7.join(CONFIG_DIR, "config.json");
+var CONFIG_DIR = path9.join(os5.homedir(), ".piut");
+var CONFIG_FILE = path9.join(CONFIG_DIR, "config.json");
 function defaultDeviceName() {
-  return os4.hostname() || "unknown";
+  return os5.hostname() || "unknown";
 }
 function generateDeviceId() {
   return `dev_${crypto.randomBytes(8).toString("hex")}`;
@@ -752,7 +1081,7 @@ function readSyncConfig() {
     backedUpFiles: []
   };
   try {
-    const raw = fs7.readFileSync(CONFIG_FILE, "utf-8");
+    const raw = fs8.readFileSync(CONFIG_FILE, "utf-8");
     const parsed = JSON.parse(raw);
     return { ...defaults, ...parsed };
   } catch {
@@ -760,8 +1089,8 @@ function readSyncConfig() {
   }
 }
 function writeSyncConfig(config) {
-  fs7.mkdirSync(CONFIG_DIR, { recursive: true });
-  fs7.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  fs8.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs8.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 function updateSyncConfig(updates) {
   const config = readSyncConfig();
@@ -880,7 +1209,7 @@ function guardAndFilter(files, options) {
   const safe = [];
   let blocked = 0;
   for (const file of files) {
-    const content = fs8.readFileSync(file.absolutePath, "utf-8");
+    const content = fs9.readFileSync(file.absolutePath, "utf-8");
     const result = guardFile(file.displayPath, content);
     if (result.blocked) {
       blocked++;
@@ -1065,7 +1394,7 @@ async function pushFlow(options) {
     try {
       const cloudFiles = await listFiles(apiKey);
       for (const localFile of safeFiles) {
-        const localContent = fs8.readFileSync(localFile.absolutePath, "utf-8");
+        const localContent = fs9.readFileSync(localFile.absolutePath, "utf-8");
         const localHash = hashContent(localContent);
         const cloudFile = cloudFiles.files.find(
           (cf) => cf.file_path === localFile.displayPath && cf.project_name === localFile.projectName
@@ -1169,14 +1498,14 @@ async function diffFlow(filePathOrId) {
   const cloudVersion = await getFileVersion(config.apiKey, fileId, versions.currentVersion);
   const cloudContent = cloudVersion.content;
   const localPath = resolveLocalPath(filePathOrId, versions.filePath);
-  if (!localPath || !fs8.existsSync(localPath)) {
+  if (!localPath || !fs9.existsSync(localPath)) {
     console.log(warning(`  Local file not found: ${filePathOrId}`));
     console.log(dim("  Showing cloud content only:"));
     console.log();
     console.log(cloudContent);
     return;
   }
-  const localContent = fs8.readFileSync(localPath, "utf-8");
+  const localContent = fs9.readFileSync(localPath, "utf-8");
   if (localContent === cloudContent) {
     console.log(success("  \u2713 Local and cloud are identical"));
     console.log();
@@ -1262,7 +1591,7 @@ async function restoreFlow(filePathOrId) {
       default: true
     });
     if (writeLocal) {
-      fs8.writeFileSync(localPath, versionData.content, "utf-8");
+      fs9.writeFileSync(localPath, versionData.content, "utf-8");
       console.log(success(`  \u2713 Local file updated: ${localPath}`));
     }
   }
@@ -1314,7 +1643,7 @@ async function watchFlow() {
       debounceMap.delete(changedPath);
       const file = safeFiles.find((f) => f.absolutePath === changedPath);
       if (!file) return;
-      const content = fs8.readFileSync(changedPath, "utf-8");
+      const content = fs9.readFileSync(changedPath, "utf-8");
       const guardResult = guardFile(file.displayPath, content);
       if (guardResult.blocked) {
         console.log(chalk3.red(`  BLOCKED ${file.displayPath}`) + dim(" (sensitive content detected)"));
@@ -1410,9 +1739,9 @@ async function installMacDaemon() {
     console.log(dim("  Cancelled."));
     return;
   }
-  fs8.mkdirSync(logDir, { recursive: true });
-  fs8.mkdirSync(plistDir, { recursive: true });
-  fs8.writeFileSync(plistPath, plistContent, "utf-8");
+  fs9.mkdirSync(logDir, { recursive: true });
+  fs9.mkdirSync(plistDir, { recursive: true });
+  fs9.writeFileSync(plistPath, plistContent, "utf-8");
   console.log(success(`  \u2713 Plist written: ${plistPath}`));
   const { execSync: execSync2 } = await import("child_process");
   try {
@@ -1485,7 +1814,7 @@ async function uploadScannedFiles(apiKey, files) {
   const payloads = files.map((file) => ({
     projectName: file.projectName,
     filePath: file.displayPath,
-    content: fs8.readFileSync(file.absolutePath, "utf-8"),
+    content: fs9.readFileSync(file.absolutePath, "utf-8"),
     category: file.type,
     deviceId: syncConfig.deviceId,
     deviceName: syncConfig.deviceName
@@ -1531,14 +1860,14 @@ async function resolveFileId(apiKey, pathOrId) {
   return match?.id || null;
 }
 function resolveLocalPath(input, cloudPath) {
-  if (fs8.existsSync(input)) return input;
-  const home2 = process.env.HOME || "";
+  if (fs9.existsSync(input)) return input;
+  const home3 = process.env.HOME || "";
   if (cloudPath.startsWith("~/")) {
-    const expanded = cloudPath.replace("~", home2);
-    if (fs8.existsSync(expanded)) return expanded;
+    const expanded = cloudPath.replace("~", home3);
+    if (fs9.existsSync(expanded)) return expanded;
   }
   const cwdPath = `${process.cwd()}/${cloudPath}`;
-  if (fs8.existsSync(cwdPath)) return cwdPath;
+  if (fs9.existsSync(cwdPath)) return cwdPath;
   return null;
 }
 async function resolveNpxPath() {
@@ -1665,12 +1994,585 @@ function parseBool(value) {
   return null;
 }
 
+// src/commands/build.ts
+import { select as select2 } from "@inquirer/prompts";
+import chalk6 from "chalk";
+
+// src/lib/auth.ts
+import { password as password3 } from "@inquirer/prompts";
+import chalk5 from "chalk";
+async function resolveApiKey(keyOption) {
+  const config = readSyncConfig();
+  let apiKey = keyOption || config.apiKey;
+  if (!apiKey) {
+    apiKey = await password3({
+      message: "Enter your p\u0131ut API key:",
+      mask: "*",
+      validate: (v) => v.startsWith("pb_") || "Key must start with pb_"
+    });
+  }
+  console.log(dim("  Validating key..."));
+  let result;
+  try {
+    result = await validateKey(apiKey);
+  } catch (err) {
+    console.log(chalk5.red(`  \u2717 ${err.message}`));
+    console.log(dim("  Get a key at https://piut.com/dashboard/keys"));
+    process.exit(1);
+  }
+  console.log(success(`  \u2713 Connected as ${result.displayName} (${result.slug})`));
+  updateSyncConfig({ apiKey });
+  return apiKey;
+}
+async function resolveApiKeyWithResult(keyOption) {
+  const config = readSyncConfig();
+  let apiKey = keyOption || config.apiKey;
+  if (!apiKey) {
+    apiKey = await password3({
+      message: "Enter your p\u0131ut API key:",
+      mask: "*",
+      validate: (v) => v.startsWith("pb_") || "Key must start with pb_"
+    });
+  }
+  console.log(dim("  Validating key..."));
+  let result;
+  try {
+    result = await validateKey(apiKey);
+  } catch (err) {
+    console.log(chalk5.red(`  \u2717 ${err.message}`));
+    console.log(dim("  Get a key at https://piut.com/dashboard/keys"));
+    process.exit(1);
+  }
+  console.log(success(`  \u2713 Connected as ${result.displayName} (${result.slug})`));
+  updateSyncConfig({ apiKey });
+  return { apiKey, ...result };
+}
+
+// src/commands/build.ts
+async function buildCommand(options) {
+  banner();
+  const apiKey = await resolveApiKey(options.key);
+  let scanFolders;
+  if (options.folders) {
+    scanFolders = options.folders.split(",").map((f) => expandPath(f.trim()));
+  }
+  const mode = scanFolders ? "auto" : await select2({
+    message: "How do you want to build your brain?",
+    choices: [
+      { name: "Automatically (recommended)", value: "auto", description: "Scan your files and build automatically" },
+      { name: "Select folder(s)...", value: "folders", description: "Choose specific folders to scan" }
+    ]
+  });
+  if (mode === "folders" && !scanFolders) {
+    const defaults = getDefaultScanDirs();
+    console.log();
+    console.log(dim("  Detected directories:"));
+    for (const d of defaults) {
+      console.log(dim(`    ${d}`));
+    }
+    console.log();
+    console.log(dim("  Tip: pass --folders ~/Projects,~/Documents to specify directly"));
+    scanFolders = defaults;
+  }
+  console.log();
+  console.log(dim("  Building your brain..."));
+  console.log();
+  const input = scanForBrain(scanFolders);
+  const projCount = input.summary.projects.length;
+  const configCount = input.summary.configFiles.length;
+  const docCount = input.summary.recentDocuments.length;
+  console.log(dim(`  Scanned: ${projCount} projects, ${configCount} config files, ${docCount} recent docs`));
+  console.log();
+  if (projCount === 0 && configCount === 0) {
+    console.log(chalk6.yellow("  No projects or config files found to build from."));
+    console.log(dim("  Try running from a directory with your projects, or use --folders."));
+    console.log();
+    return;
+  }
+  try {
+    const sections = await buildBrain(apiKey, input);
+    const sectionSummary = (content, label) => {
+      if (!content || !content.trim()) {
+        console.log(dim(`  ${label} \u2014 (empty)`));
+      } else {
+        const firstLine = content.split("\n").find((l) => l.trim() && !l.startsWith("#"))?.trim() || "";
+        const preview = firstLine.length > 60 ? firstLine.slice(0, 60) + "..." : firstLine;
+        console.log(success(`  ${label}`) + dim(` \u2014 ${preview}`));
+      }
+    };
+    console.log(success("  Brain built!"));
+    console.log();
+    sectionSummary(sections.about, "About");
+    sectionSummary(sections.soul, "Soul");
+    sectionSummary(sections.areas, "Areas of Responsibility");
+    sectionSummary(sections.projects, "Projects");
+    sectionSummary(sections.memory, "Memory");
+    console.log();
+    console.log(dim(`  Review and edit at ${brand("piut.com/dashboard")}`));
+    console.log();
+  } catch (err) {
+    console.log(chalk6.red(`  \u2717 ${err.message}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/deploy.ts
+import { confirm as confirm4 } from "@inquirer/prompts";
+import chalk7 from "chalk";
+async function deployCommand(options) {
+  banner();
+  const { apiKey, slug, serverUrl } = await resolveApiKeyWithResult(options.key);
+  console.log();
+  console.log(dim("  Your brain will be published as an MCP server at:"));
+  console.log(`  ${brand(serverUrl)}`);
+  console.log();
+  console.log(dim("  Any AI tool with this URL can read your brain."));
+  console.log();
+  if (!options.yes) {
+    const proceed = await confirm4({
+      message: "Deploy?",
+      default: true
+    });
+    if (!proceed) {
+      console.log(dim("  Cancelled."));
+      return;
+    }
+  }
+  try {
+    await publishServer(apiKey);
+    console.log();
+    console.log(success("  \u2713 Brain deployed. MCP server live."));
+    console.log(dim(`  URL: ${serverUrl}`));
+    console.log();
+    console.log(dim("  Next: run ") + brand("piut connect") + dim(" to add brain references to your projects."));
+    console.log();
+  } catch (err) {
+    const msg = err.message;
+    if (msg === "REQUIRES_SUBSCRIPTION") {
+      console.log();
+      console.log(chalk7.yellow("  Deploy requires an active subscription ($10/mo)."));
+      console.log();
+      console.log(`  Subscribe at: ${brand("https://piut.com/dashboard/billing")}`);
+      console.log(dim("  14-day free trial included."));
+      console.log();
+    } else {
+      console.log(chalk7.red(`  \u2717 ${msg}`));
+      process.exit(1);
+    }
+  }
+}
+
+// src/commands/connect.ts
+import fs10 from "fs";
+import path10 from "path";
+import { checkbox as checkbox4 } from "@inquirer/prompts";
+var RULE_FILES = [
+  {
+    tool: "Claude Code",
+    filePath: "CLAUDE.md",
+    strategy: "append",
+    detect: (p) => p.hasClaudeMd || fs10.existsSync(path10.join(p.path, ".claude"))
+  },
+  {
+    tool: "Cursor",
+    filePath: ".cursor/rules/piut.mdc",
+    strategy: "create",
+    detect: (p) => p.hasCursorRules || fs10.existsSync(path10.join(p.path, ".cursor"))
+  },
+  {
+    tool: "Windsurf",
+    filePath: ".windsurf/rules/piut.md",
+    strategy: "create",
+    detect: (p) => p.hasWindsurfRules || fs10.existsSync(path10.join(p.path, ".windsurf"))
+  },
+  {
+    tool: "GitHub Copilot",
+    filePath: ".github/copilot-instructions.md",
+    strategy: "append",
+    detect: (p) => p.hasCopilotInstructions || fs10.existsSync(path10.join(p.path, ".github"))
+  },
+  {
+    tool: "Amazon Q",
+    filePath: "CONVENTIONS.md",
+    strategy: "append",
+    detect: (p) => p.hasConventionsMd
+  },
+  {
+    tool: "Zed",
+    filePath: ".zed/rules.md",
+    strategy: "create",
+    detect: (p) => p.hasZedRules || fs10.existsSync(path10.join(p.path, ".zed"))
+  }
+];
+var DEDICATED_FILE_CONTENT = `## p\u0131ut Context
+This project uses p\u0131ut for persistent personal context.
+Skill reference: https://raw.githubusercontent.com/M-Flat-Inc/piut/main/skill.md
+
+Always call \`get_context\` at the start of every conversation.
+Read the \`soul\` section first \u2014 it contains behavioral instructions.
+Use \`update_brain\` for substantial new info, \`append_brain\` for quick notes.
+`;
+var APPEND_SECTION = `
+
+## p\u0131ut Context
+Skill reference: https://raw.githubusercontent.com/M-Flat-Inc/piut/main/skill.md
+Always call \`get_context\` at the start of every conversation to load personal context.
+`;
+function hasPiutReference2(filePath) {
+  try {
+    const content = fs10.readFileSync(filePath, "utf-8");
+    return content.includes("p\u0131ut Context") || content.includes("piut Context");
+  } catch {
+    return false;
+  }
+}
+async function connectCommand(options) {
+  banner();
+  await resolveApiKeyWithResult(options.key);
+  let scanFolders;
+  if (options.folders) {
+    scanFolders = options.folders.split(",").map((f) => expandPath(f.trim()));
+  }
+  console.log();
+  console.log(dim("  Scanning for projects..."));
+  const projects = scanForProjects(scanFolders);
+  if (projects.length === 0) {
+    console.log(warning("  No projects found."));
+    console.log(dim("  Try running from a directory with your projects, or use --folders."));
+    console.log();
+    return;
+  }
+  const actions = [];
+  for (const project of projects) {
+    for (const rule of RULE_FILES) {
+      if (!rule.detect(project)) continue;
+      const absPath = path10.join(project.path, rule.filePath);
+      if (fs10.existsSync(absPath) && hasPiutReference2(absPath)) continue;
+      actions.push({
+        project,
+        tool: rule.tool,
+        filePath: rule.filePath,
+        absPath,
+        action: rule.strategy === "create" || !fs10.existsSync(absPath) ? "create" : "append"
+      });
+    }
+    const hasAnyAction = actions.some((a) => a.project === project);
+    if (!hasAnyAction) {
+      const claudeMdPath = path10.join(project.path, "CLAUDE.md");
+      if (!fs10.existsSync(claudeMdPath)) {
+        actions.push({
+          project,
+          tool: "Claude Code",
+          filePath: "CLAUDE.md",
+          absPath: claudeMdPath,
+          action: "create"
+        });
+      } else if (!hasPiutReference2(claudeMdPath)) {
+        actions.push({
+          project,
+          tool: "Claude Code",
+          filePath: "CLAUDE.md",
+          absPath: claudeMdPath,
+          action: "append"
+        });
+      }
+    }
+  }
+  if (actions.length === 0) {
+    console.log(dim("  All projects are already connected."));
+    console.log();
+    return;
+  }
+  const byProject = /* @__PURE__ */ new Map();
+  for (const action of actions) {
+    const key = action.project.path;
+    if (!byProject.has(key)) byProject.set(key, []);
+    byProject.get(key).push(action);
+  }
+  console.log();
+  console.log(`  Found ${brand.bold(String(byProject.size))} project(s) to connect:`);
+  console.log();
+  const projectChoices = [];
+  for (const [projectPath, projectActions] of byProject) {
+    const projectName = path10.basename(projectPath);
+    const desc = projectActions.map((a) => {
+      const verb = a.action === "create" ? "will create" : "will append to";
+      return `${verb} ${a.filePath}`;
+    }).join(", ");
+    projectChoices.push({
+      name: `${projectName} ${dim(`(${desc})`)}`,
+      value: projectPath,
+      checked: true
+    });
+  }
+  let selectedPaths;
+  if (options.yes) {
+    selectedPaths = Array.from(byProject.keys());
+  } else {
+    selectedPaths = await checkbox4({
+      message: "Select projects to connect:",
+      choices: projectChoices
+    });
+    if (selectedPaths.length === 0) {
+      console.log(dim("  No projects selected."));
+      return;
+    }
+  }
+  console.log();
+  let connected = 0;
+  for (const projectPath of selectedPaths) {
+    const projectActions = byProject.get(projectPath) || [];
+    const projectName = path10.basename(projectPath);
+    for (const action of projectActions) {
+      if (action.action === "create") {
+        const isAppendType = RULE_FILES.find((r) => r.filePath === action.filePath)?.strategy === "append";
+        const content = isAppendType ? SKILL_SNIPPET + "\n" : DEDICATED_FILE_CONTENT;
+        fs10.mkdirSync(path10.dirname(action.absPath), { recursive: true });
+        fs10.writeFileSync(action.absPath, content, "utf-8");
+        console.log(success(`  \u2713 ${projectName}/${action.filePath}`) + dim(" \u2014 created"));
+      } else {
+        fs10.appendFileSync(action.absPath, APPEND_SECTION);
+        console.log(success(`  \u2713 ${projectName}/${action.filePath}`) + dim(" \u2014 appended"));
+      }
+      connected++;
+    }
+  }
+  console.log();
+  console.log(success(`  Done. ${connected} file(s) updated across ${selectedPaths.length} project(s).`));
+  console.log();
+}
+
+// src/commands/disconnect.ts
+import fs11 from "fs";
+import path11 from "path";
+import { checkbox as checkbox5, confirm as confirm6 } from "@inquirer/prompts";
+var DEDICATED_FILES = /* @__PURE__ */ new Set([
+  ".cursor/rules/piut.mdc",
+  ".windsurf/rules/piut.md",
+  ".zed/rules.md"
+]);
+var APPEND_FILES = [
+  "CLAUDE.md",
+  ".github/copilot-instructions.md",
+  "CONVENTIONS.md"
+];
+function hasPiutReference3(filePath) {
+  try {
+    const content = fs11.readFileSync(filePath, "utf-8");
+    return content.includes("p\u0131ut Context") || content.includes("piut Context");
+  } catch {
+    return false;
+  }
+}
+function removePiutSection(filePath) {
+  try {
+    let content = fs11.readFileSync(filePath, "utf-8");
+    const patterns = [
+      /\n*## p[ıi]ut Context[\s\S]*?(?=\n## |\n---\n|$)/g
+    ];
+    let changed = false;
+    for (const pattern of patterns) {
+      const newContent = content.replace(pattern, "");
+      if (newContent !== content) {
+        content = newContent;
+        changed = true;
+      }
+    }
+    if (changed) {
+      content = content.replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+      fs11.writeFileSync(filePath, content, "utf-8");
+    }
+    return changed;
+  } catch {
+    return false;
+  }
+}
+async function disconnectCommand(options) {
+  banner();
+  let scanFolders;
+  if (options.folders) {
+    scanFolders = options.folders.split(",").map((f) => expandPath(f.trim()));
+  }
+  console.log(dim("  Scanning for connected projects..."));
+  const projects = scanForProjects(scanFolders);
+  const actions = [];
+  for (const project of projects) {
+    const projectName = path11.basename(project.path);
+    for (const dedicatedFile of DEDICATED_FILES) {
+      const absPath = path11.join(project.path, dedicatedFile);
+      if (fs11.existsSync(absPath) && hasPiutReference3(absPath)) {
+        actions.push({
+          projectPath: project.path,
+          projectName,
+          filePath: dedicatedFile,
+          absPath,
+          action: "delete"
+        });
+      }
+    }
+    for (const appendFile of APPEND_FILES) {
+      const absPath = path11.join(project.path, appendFile);
+      if (fs11.existsSync(absPath) && hasPiutReference3(absPath)) {
+        actions.push({
+          projectPath: project.path,
+          projectName,
+          filePath: appendFile,
+          absPath,
+          action: "remove-section"
+        });
+      }
+    }
+  }
+  if (actions.length === 0) {
+    console.log(dim("  No connected projects found."));
+    console.log();
+    return;
+  }
+  const byProject = /* @__PURE__ */ new Map();
+  for (const action of actions) {
+    if (!byProject.has(action.projectPath)) byProject.set(action.projectPath, []);
+    byProject.get(action.projectPath).push(action);
+  }
+  console.log();
+  const projectChoices = Array.from(byProject.entries()).map(([projectPath, projectActions]) => {
+    const name = path11.basename(projectPath);
+    const files = projectActions.map((a) => a.filePath).join(", ");
+    return {
+      name: `${name} ${dim(`(${files})`)}`,
+      value: projectPath,
+      checked: true
+    };
+  });
+  let selectedPaths;
+  if (options.yes) {
+    selectedPaths = Array.from(byProject.keys());
+  } else {
+    selectedPaths = await checkbox5({
+      message: "Select projects to disconnect:",
+      choices: projectChoices
+    });
+    if (selectedPaths.length === 0) {
+      console.log(dim("  No projects selected."));
+      return;
+    }
+    const proceed = await confirm6({
+      message: `Disconnect ${selectedPaths.length} project(s)?`,
+      default: false
+    });
+    if (!proceed) return;
+  }
+  console.log();
+  let disconnected = 0;
+  for (const projectPath of selectedPaths) {
+    const projectActions = byProject.get(projectPath) || [];
+    const projectName = path11.basename(projectPath);
+    for (const action of projectActions) {
+      if (action.action === "delete") {
+        try {
+          fs11.unlinkSync(action.absPath);
+          console.log(success(`  \u2713 ${projectName}/${action.filePath}`) + dim(" \u2014 deleted"));
+          disconnected++;
+        } catch {
+          console.log(warning(`  \u2717 ${projectName}/${action.filePath}`) + dim(" \u2014 could not delete"));
+        }
+      } else {
+        const removed = removePiutSection(action.absPath);
+        if (removed) {
+          console.log(success(`  \u2713 ${projectName}/${action.filePath}`) + dim(" \u2014 section removed"));
+          disconnected++;
+        } else {
+          console.log(warning(`  \u2717 ${projectName}/${action.filePath}`) + dim(" \u2014 section not found"));
+        }
+      }
+    }
+  }
+  console.log();
+  console.log(success(`  Done. ${disconnected} file(s) updated.`));
+  console.log();
+}
+
+// src/commands/interactive.ts
+import { select as select3 } from "@inquirer/prompts";
+import chalk8 from "chalk";
+import { password as password4 } from "@inquirer/prompts";
+async function authenticate() {
+  const config = readSyncConfig();
+  let apiKey = config.apiKey;
+  if (apiKey) {
+    try {
+      const result2 = await validateKey(apiKey);
+      console.log(success(`  Connected as ${result2.displayName} (${result2.slug})`));
+      return apiKey;
+    } catch {
+      console.log(dim("  Saved key expired. Please re-authenticate."));
+      apiKey = void 0;
+    }
+  }
+  console.log(dim("  Connect to p\u0131ut:"));
+  console.log(dim("    > Log in at piut.com"));
+  console.log(dim("    > Enter p\u0131ut API key"));
+  console.log();
+  apiKey = await password4({
+    message: "Enter your p\u0131ut API key:",
+    mask: "*",
+    validate: (v) => v.startsWith("pb_") || "Key must start with pb_"
+  });
+  console.log(dim("  Validating key..."));
+  let result;
+  try {
+    result = await validateKey(apiKey);
+  } catch (err) {
+    console.log(chalk8.red(`  \u2717 ${err.message}`));
+    console.log(dim("  Get a key at https://piut.com/dashboard/keys"));
+    process.exit(1);
+  }
+  console.log(success(`  \u2713 Connected as ${result.displayName} (${result.slug})`));
+  updateSyncConfig({ apiKey });
+  return apiKey;
+}
+async function interactiveMenu() {
+  banner();
+  const apiKey = await authenticate();
+  console.log();
+  const action = await select3({
+    message: "What would you like to do?",
+    choices: [
+      { name: "Build Brain", value: "build", description: "Build or rebuild your brain from your files" },
+      { name: "Deploy Brain", value: "deploy", description: "Publish your MCP server (requires paid account)" },
+      { name: "Connect Projects", value: "connect", description: "Add brain references to project config files" },
+      { name: "Disconnect Projects", value: "disconnect", description: "Remove brain references from project configs" },
+      { name: "Status", value: "status", description: "Show brain, deployment, and connected projects" }
+    ]
+  });
+  switch (action) {
+    case "build":
+      await buildCommand({ key: apiKey });
+      break;
+    case "deploy":
+      await deployCommand({ key: apiKey });
+      break;
+    case "connect":
+      await connectCommand({ key: apiKey });
+      break;
+    case "disconnect":
+      await disconnectCommand({});
+      break;
+    case "status":
+      statusCommand();
+      break;
+  }
+}
+
 // src/cli.ts
 var program = new Command();
-program.name("piut").description("Automatic backup + hosting of all your agent configs across every machine. Version history. Restore any time. One command to set up.").version("1.1.0");
-program.command("setup", { isDefault: true }).description("Auto-detect and configure AI tools").option("-k, --key <key>", "API key (prompts interactively if not provided)").option("-t, --tool <id>", "Configure a single tool (claude-code, cursor, windsurf, etc.)").option("-y, --yes", "Skip interactive prompts (auto-select all detected tools)").option("--project", "Prefer project-local config files").option("--skip-skill", "Skip skill.md file placement").action(setupCommand);
-program.command("status").description("Show which AI tools are configured with p\u0131ut").action(statusCommand);
-program.command("remove").description("Remove p\u0131ut configuration from AI tools").action(removeCommand);
-var sync = program.command("sync").description("Back up and sync your agent config files to the cloud").option("--install", "Run the guided backup setup flow").option("--push", "Push local changes to cloud").option("--pull", "Pull latest versions from cloud").option("--watch", "Watch files for changes and auto-push (live sync)").option("--history <file>", "Show version history for a file").option("--diff <file>", "Show diff between local and cloud version").option("--restore <file>", "Restore a file from a previous version").option("--prefer-local", "Resolve conflicts by keeping local version").option("--prefer-cloud", "Resolve conflicts by keeping cloud version").option("--install-daemon", "Set up auto-sync via cron/launchd").option("-k, --key <key>", "API key").option("-y, --yes", "Skip interactive prompts").action(syncCommand);
-sync.command("config").description("Configure cloud backup settings").option("--files", "Change which files are backed up").option("--auto-discover <value>", "Auto-backup new files (on/off)").option("--keep-brain-updated <value>", "Keep brain updated from backups (on/off)").option("--use-brain <value>", "Reference centralized brain (on/off)").option("--show", "View current configuration").action(syncConfigCommand);
+program.name("piut").description("Build your AI brain instantly. Deploy it as an MCP server. Connect it to every project.").version("2.0.0").action(interactiveMenu);
+program.command("build").description("Build or rebuild your brain from your files").option("-k, --key <key>", "API key").option("--folders <paths>", "Comma-separated folder paths to scan").action(buildCommand);
+program.command("deploy").description("Publish your MCP server (requires paid account)").option("-k, --key <key>", "API key").option("-y, --yes", "Skip confirmation prompts").action(deployCommand);
+program.command("connect").description("Add brain references to project config files").option("-k, --key <key>", "API key").option("-y, --yes", "Skip interactive prompts").option("--folders <paths>", "Comma-separated folder paths to scan").action(connectCommand);
+program.command("disconnect").description("Remove brain references from project config files").option("-y, --yes", "Skip interactive prompts").option("--folders <paths>", "Comma-separated folder paths to scan").action(disconnectCommand);
+program.command("setup").description("Auto-detect and configure AI tools (MCP config)").option("-k, --key <key>", "API key (prompts interactively if not provided)").option("-t, --tool <id>", "Configure a single tool (claude-code, cursor, windsurf, etc.)").option("-y, --yes", "Skip interactive prompts (auto-select all detected tools)").option("--project", "Prefer project-local config files").option("--skip-skill", "Skip skill.md file placement").action(setupCommand);
+program.command("status").description("Show brain, deployment, and connected projects").action(statusCommand);
+program.command("remove").description("Remove all p\u0131ut configurations").action(removeCommand);
+var sync = program.command("sync").description("Sync your agent config files to the cloud").option("--install", "Run the guided sync setup flow").option("--push", "Push local changes to cloud").option("--pull", "Pull latest versions from cloud").option("--watch", "Watch files for changes and auto-push (live sync)").option("--history <file>", "Show version history for a file").option("--diff <file>", "Show diff between local and cloud version").option("--restore <file>", "Restore a file from a previous version").option("--prefer-local", "Resolve conflicts by keeping local version").option("--prefer-cloud", "Resolve conflicts by keeping cloud version").option("--install-daemon", "Set up auto-sync via cron/launchd").option("-k, --key <key>", "API key").option("-y, --yes", "Skip interactive prompts").action(syncCommand);
+sync.command("config").description("Configure sync settings").option("--files", "Change which files are synced").option("--auto-discover <value>", "Auto-sync new files (on/off)").option("--keep-brain-updated <value>", "Keep brain updated from synced files (on/off)").option("--use-brain <value>", "Reference centralized brain (on/off)").option("--show", "View current configuration").action(syncConfigCommand);
 program.parse();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@piut/cli",
-  "version": "1.1.0",
-  "description": "Automatic backup + hosting of all your agent configs across every machine. Version history. Restore any time. One command to set up.",
+  "version": "2.0.0",
+  "description": "Build your AI brain instantly. Deploy it as an MCP server. Connect it to every project.",
   "type": "module",
   "bin": {
     "piut": "dist/cli.js"
@@ -20,16 +20,15 @@
   "keywords": [
     "mcp",
     "ai",
+    "brain",
     "context",
     "cli",
     "claude",
     "cursor",
     "copilot",
     "windsurf",
-    "backup",
-    "sync",
-    "cloud",
-    "agent-config"
+    "deploy",
+    "personal-context"
   ],
   "author": "M-Flat Inc",
   "license": "MIT",