@aiorg/cli 1.1.6 → 1.2.0

package/dist/index.js

@@ -30,6 +30,13 @@ var LatestVersionSchema = z.object({
   packageName: z.string(),
   packageDisplayName: z.string(),
   changelog: z.record(z.string(), z.any()).optional(),
+  allVersions: z.array(
+    z.object({
+      version: z.string(),
+      changelog: z.record(z.string(), z.any()).optional(),
+      releasedAt: z.string().optional()
+    })
+  ).optional(),
   tier: z.enum(["free", "paid", "private"]).optional(),
   type: z.enum(["template", "companion", "inject"]).optional()
 });
@@ -384,10 +391,10 @@ async function logout() {
 }
 
 // src/commands/init.ts
-import * as p3 from "@clack/prompts";
-import pc4 from "picocolors";
-import path3 from "path";
-import os3 from "os";
+import * as p4 from "@clack/prompts";
+import pc5 from "picocolors";
+import path4 from "path";
+import os4 from "os";
 
 // src/lib/extract.ts
 import extractZip from "extract-zip";
@@ -428,21 +435,301 @@ async function getFileSizeKB(filePath) {
   return Math.round(stats.size / 1024);
 }
 
+// src/lib/project.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+import os3 from "os";
+import * as p3 from "@clack/prompts";
+import pc4 from "picocolors";
+import { z as z3 } from "zod";
+var AiorgFileSchema = z3.object({
+  project: z3.string(),
+  version: z3.string().optional()
+});
+var ContextJsonSchema = z3.object({
+  version: z3.string(),
+  business: z3.object({
+    name: z3.string(),
+    description: z3.string().optional(),
+    stage: z3.enum(["idea", "building", "launched", "pmf", "scaling"]).optional(),
+    launchDate: z3.string().optional()
+  }),
+  validation: z3.object({
+    ideaValidated: z3.boolean().optional(),
+    ideaScore: z3.number().optional(),
+    targetCustomer: z3.string().optional(),
+    valueProp: z3.string().optional(),
+    validatedAt: z3.string().optional()
+  }).optional(),
+  pmf: z3.object({
+    status: z3.enum(["not-started", "searching", "approaching", "achieved"]).optional(),
+    score: z3.number().nullable().optional(),
+    seanEllisScore: z3.number().nullable().optional(),
+    activationRate: z3.number().nullable().optional(),
+    weeklyRetention: z3.number().nullable().optional(),
+    measuredAt: z3.string().nullable().optional()
+  }).optional(),
+  installedKits: z3.array(z3.string()).optional(),
+  lastUpdated: z3.string(),
+  updatedBy: z3.string()
+});
+function getAiorgDir() {
+  return path3.join(os3.homedir(), ".aiorg");
+}
+function getProjectsDir() {
+  return path3.join(getAiorgDir(), "projects");
+}
+function getProjectDir(projectName) {
+  return path3.join(getProjectsDir(), projectName);
+}
+async function initializeAiorg() {
+  const aiorgDir = getAiorgDir();
+  const projectsDir = getProjectsDir();
+  await fs3.ensureDir(projectsDir);
+  const configPath = path3.join(aiorgDir, "config.json");
+  if (!await fs3.pathExists(configPath)) {
+    await fs3.writeJson(configPath, {
+      version: "1.0.0",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }, { spaces: 2 });
+  }
+}
+async function listProjects() {
+  const projectsDir = getProjectsDir();
+  if (!await fs3.pathExists(projectsDir)) {
+    return [];
+  }
+  const entries = await fs3.readdir(projectsDir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+}
+async function createProject(projectName, businessName, kitName) {
+  const projectDir = getProjectDir(projectName);
+  await initializeAiorg();
+  await fs3.ensureDir(projectDir);
+  const contextJson = {
+    version: "1.0.0",
+    business: {
+      name: businessName,
+      stage: "building"
+    },
+    validation: {},
+    pmf: {
+      status: "not-started",
+      score: null,
+      seanEllisScore: null,
+      activationRate: null,
+      weeklyRetention: null,
+      measuredAt: null
+    },
+    installedKits: [kitName],
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedBy: kitName
+  };
+  await fs3.writeJson(
+    path3.join(projectDir, "context.json"),
+    contextJson,
+    { spaces: 2 }
+  );
+  await fs3.writeJson(
+    path3.join(projectDir, "learnings.json"),
+    {
+      version: "1.0.0",
+      whatWorks: [],
+      whatDoesntWork: []
+    },
+    { spaces: 2 }
+  );
+}
+async function readAiorgFile(dirPath) {
+  const aiorgPath = path3.join(dirPath, ".aiorg");
+  if (!await fs3.pathExists(aiorgPath)) {
+    return null;
+  }
+  try {
+    const content = await fs3.readJson(aiorgPath);
+    return AiorgFileSchema.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function writeAiorgFile(dirPath, projectName) {
+  const aiorgPath = path3.join(dirPath, ".aiorg");
+  const aiorgFile = {
+    project: projectName,
+    version: "1.0.0"
+  };
+  await fs3.writeJson(aiorgPath, aiorgFile, { spaces: 2 });
+}
+async function addKitToProject(projectName, kitName) {
+  const contextPath = path3.join(getProjectDir(projectName), "context.json");
+  if (!await fs3.pathExists(contextPath)) {
+    return;
+  }
+  try {
+    const context = await fs3.readJson(contextPath);
+    const installedKits = context.installedKits || [];
+    if (!installedKits.includes(kitName)) {
+      installedKits.push(kitName);
+      context.installedKits = installedKits;
+      context.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+      await fs3.writeJson(contextPath, context, { spaces: 2 });
+    }
+  } catch {
+  }
+}
+async function readProjectContext(projectName) {
+  const contextPath = path3.join(getProjectDir(projectName), "context.json");
+  if (!await fs3.pathExists(contextPath)) {
+    return null;
+  }
+  try {
+    const content = await fs3.readJson(contextPath);
+    return ContextJsonSchema.parse(content);
+  } catch {
+    return null;
+  }
+}
+function suggestProjectName(dirPath) {
+  const dirName = path3.basename(dirPath);
+  return dirName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+async function setupProject(targetPath, kitName, options = {}) {
+  const existingAiorg = await readAiorgFile(targetPath);
+  if (existingAiorg) {
+    await addKitToProject(existingAiorg.project, kitName);
+    if (!options.silent) {
+      const context = await readProjectContext(existingAiorg.project);
+      if (context) {
+        blank();
+        info(`Linked to project: ${pc4.cyan(existingAiorg.project)}`);
+        if (context.business?.name) {
+          log(pc4.dim(`  Business: ${context.business.name}`));
+        }
+        if (context.installedKits && context.installedKits.length > 0) {
+          log(pc4.dim(`  Installed kits: ${context.installedKits.join(", ")}`));
+        }
+      }
+    }
+    return existingAiorg.project;
+  }
+  await initializeAiorg();
+  const existingProjects = await listProjects();
+  let projectName;
+  if (existingProjects.length > 0) {
+    blank();
+    header("Project Setup");
+    log(pc4.dim("AI Org kits can share context across a project."));
+    blank();
+    const projectChoice = await p3.select({
+      message: "Link this kit to:",
+      options: [
+        ...existingProjects.map((name) => ({
+          value: name,
+          label: name,
+          hint: "existing project"
+        })),
+        {
+          value: "__new__",
+          label: "Create new project",
+          hint: "start fresh"
+        }
+      ]
+    });
+    if (p3.isCancel(projectChoice)) {
+      return null;
+    }
+    if (projectChoice === "__new__") {
+      const newProjectName = await askForNewProject(targetPath, kitName);
+      if (!newProjectName) return null;
+      projectName = newProjectName;
+    } else {
+      projectName = projectChoice;
+      await addKitToProject(projectName, kitName);
+    }
+  } else {
+    blank();
+    header("Project Setup");
+    log(pc4.dim("AI Org kits share context through projects."));
+    log(pc4.dim("This helps kits work together and remember your business."));
+    blank();
+    const newProjectName = await askForNewProject(targetPath, kitName);
+    if (!newProjectName) return null;
+    projectName = newProjectName;
+  }
+  await writeAiorgFile(targetPath, projectName);
+  if (!options.silent) {
+    blank();
+    success(`Project ${pc4.cyan(projectName)} linked`);
+    log(pc4.dim(`  Context: ~/.aiorg/projects/${projectName}/`));
+  }
+  return projectName;
+}
+async function askForNewProject(targetPath, kitName) {
+  const suggestedName = suggestProjectName(targetPath);
+  const projectName = await p3.text({
+    message: "Project name:",
+    placeholder: suggestedName,
+    defaultValue: suggestedName,
+    validate: (value) => {
+      if (!value) return "Project name is required";
+      if (!/^[a-z0-9-]+$/.test(value)) {
+        return "Use lowercase letters, numbers, and hyphens only";
+      }
+      return void 0;
+    }
+  });
+  if (p3.isCancel(projectName)) {
+    return null;
+  }
+  const businessName = await p3.text({
+    message: "Business/product name:",
+    placeholder: "My Startup",
+    validate: (value) => {
+      if (!value) return "Business name is required";
+      return void 0;
+    }
+  });
+  if (p3.isCancel(businessName)) {
+    return null;
+  }
+  await createProject(
+    projectName,
+    businessName,
+    kitName
+  );
+  return projectName;
+}
+async function needsProjectMigration(dirPath) {
+  const aiorgFile = await readAiorgFile(dirPath);
+  if (aiorgFile) {
+    return false;
+  }
+  const hasClaudeDir = await fs3.pathExists(path3.join(dirPath, ".claude"));
+  const hasVersionJson = await fs3.pathExists(path3.join(dirPath, ".claude", "version.json"));
+  return hasClaudeDir && hasVersionJson;
+}
+async function migrateToProjectSystem(dirPath, kitName) {
+  blank();
+  info("This kit installation needs to be linked to a project.");
+  log(pc4.dim("Projects allow kits to share context and work together."));
+  return setupProject(dirPath, kitName);
+}
+
 // src/commands/init.ts
 async function init(kitName, targetPath, options) {
-  p3.intro(pc4.cyan(`aiorg init ${kitName}`));
-  const resolvedPath = targetPath ? path3.resolve(targetPath.replace(/^~/, os3.homedir())) : path3.resolve(process.cwd(), kitName);
+  p4.intro(pc5.cyan(`aiorg init ${kitName}`));
+  const resolvedPath = targetPath ? path4.resolve(targetPath.replace(/^~/, os4.homedir())) : path4.resolve(process.cwd(), kitName);
   if (!options.force && await dirExistsAndNotEmpty(resolvedPath)) {
-    error(`Folder already exists: ${pc4.yellow(resolvedPath)}`);
-    log(pc4.dim("Use --force to overwrite"));
+    error(`Folder already exists: ${pc5.yellow(resolvedPath)}`);
+    log(pc5.dim("Use --force to overwrite"));
     process.exit(1);
   }
-  const spinner4 = p3.spinner();
+  const spinner4 = p4.spinner();
   spinner4.start("Fetching version info...");
   let versionInfo;
   try {
     versionInfo = await fetchLatestVersion(kitName);
-    spinner4.stop(`Found ${pc4.cyan(versionInfo.packageDisplayName)} v${versionInfo.version}`);
+    spinner4.stop(`Found ${pc5.cyan(versionInfo.packageDisplayName)} v${versionInfo.version}`);
   } catch (error2) {
     spinner4.stop("Failed to fetch version info");
     throw error2;
@@ -479,14 +766,14 @@ async function init(kitName, targetPath, options) {
   let tempDir = null;
   try {
     tempDir = await createTempDir("aiorg-init-");
-    const zipPath = path3.join(tempDir, "kit.zip");
+    const zipPath = path4.join(tempDir, "kit.zip");
     const zipData = await downloadFile(downloadInfo.downloadUrl);
     await saveToFile(zipData, zipPath);
     const sizeKB = await getFileSizeKB(zipPath);
     spinner4.stop(`Downloaded ${kitName} v${versionInfo.version} (${sizeKB} KB)`);
     spinner4.start(`Extracting to ${resolvedPath}...`);
     await extractZipToDir(zipPath, resolvedPath);
-    spinner4.stop(`Extracted to ${pc4.yellow(resolvedPath)}`);
+    spinner4.stop(`Extracted to ${pc5.yellow(resolvedPath)}`);
     await cleanupTempDir(tempDir);
   } catch (error2) {
     if (tempDir) {
@@ -496,6 +783,7 @@ async function init(kitName, targetPath, options) {
   }
   blank();
   success(`${versionInfo.packageDisplayName} v${versionInfo.version} installed!`);
+  await setupProject(resolvedPath, kitName);
   blank();
   log("Next steps:");
   listItem(`cd ${resolvedPath}`);
@@ -504,52 +792,52 @@ async function init(kitName, targetPath, options) {
   const outroMessages = {
     "investor-os": "Happy investing!"
   };
-  const outro5 = outroMessages[kitName] || "Happy building!";
-  p3.outro(pc4.green(outro5));
+  const outro6 = outroMessages[kitName] || "Happy building!";
+  p4.outro(pc5.green(outro6));
 }
 
 // src/commands/upgrade.ts
-import * as p4 from "@clack/prompts";
-import pc5 from "picocolors";
-import path6 from "path";
+import * as p5 from "@clack/prompts";
+import pc6 from "picocolors";
+import path7 from "path";
 import semver from "semver";
 
 // src/lib/detect.ts
-import fs3 from "fs-extra";
-import path4 from "path";
-import { z as z3 } from "zod";
-var VersionJsonSchema = z3.object({
-  version: z3.string(),
-  packageName: z3.string(),
-  packageDisplayName: z3.string().optional(),
-  releasedAt: z3.string().optional(),
-  minUpgradeFrom: z3.string().optional(),
-  fileCategories: z3.object({
-    alwaysReplace: z3.array(z3.string()).optional(),
-    neverTouch: z3.array(z3.string()).optional(),
-    mergeIfChanged: z3.array(z3.string()).optional(),
-    addOnly: z3.array(z3.string()).optional()
+import fs4 from "fs-extra";
+import path5 from "path";
+import { z as z4 } from "zod";
+var VersionJsonSchema = z4.object({
+  version: z4.string(),
+  packageName: z4.string(),
+  packageDisplayName: z4.string().optional(),
+  releasedAt: z4.string().optional(),
+  minUpgradeFrom: z4.string().optional(),
+  fileCategories: z4.object({
+    alwaysReplace: z4.array(z4.string()).optional(),
+    neverTouch: z4.array(z4.string()).optional(),
+    mergeIfChanged: z4.array(z4.string()).optional(),
+    addOnly: z4.array(z4.string()).optional()
   }).optional(),
-  changelog: z3.record(z3.string(), z3.any()).optional()
+  changelog: z4.record(z4.string(), z4.any()).optional()
 });
-var KitJsonSchema = z3.object({
-  name: z3.string(),
-  displayName: z3.string().optional(),
-  type: z3.enum(["bootstrap", "inject"]).optional()
+var KitJsonSchema = z4.object({
+  name: z4.string(),
+  displayName: z4.string().optional(),
+  type: z4.enum(["bootstrap", "inject"]).optional()
 });
 async function detectKit(dirPath) {
-  const versionJsonPath = path4.join(dirPath, ".claude", "version.json");
-  const kitJsonPath = path4.join(dirPath, ".claude", "kit.json");
-  if (!await fs3.pathExists(versionJsonPath)) {
+  const versionJsonPath = path5.join(dirPath, ".claude", "version.json");
+  const kitJsonPath = path5.join(dirPath, ".claude", "kit.json");
+  if (!await fs4.pathExists(versionJsonPath)) {
     return null;
   }
   try {
-    const versionRaw = await fs3.readJson(versionJsonPath);
+    const versionRaw = await fs4.readJson(versionJsonPath);
     const versionJson = VersionJsonSchema.parse(versionRaw);
     let kitJson;
-    if (await fs3.pathExists(kitJsonPath)) {
+    if (await fs4.pathExists(kitJsonPath)) {
       try {
-        const kitRaw = await fs3.readJson(kitJsonPath);
+        const kitRaw = await fs4.readJson(kitJsonPath);
         kitJson = KitJsonSchema.parse(kitRaw);
       } catch {
       }
@@ -571,8 +859,8 @@ async function detectKitInCwd() {
 }
 
 // src/lib/apply.ts
-import fs4 from "fs-extra";
-import path5 from "path";
+import fs5 from "fs-extra";
+import path6 from "path";
 import { glob } from "glob";
 import { minimatch } from "minimatch";
 import { merge } from "lodash-es";
@@ -610,11 +898,11 @@ async function applyFileCategories(sourceDir, destDir, versionJson) {
           processedFiles.add(file);
           continue;
         }
-        const srcPath = path5.join(sourceDir, file);
-        const destPath = path5.join(destDir, file);
+        const srcPath = path6.join(sourceDir, file);
+        const destPath = path6.join(destDir, file);
         try {
-          await fs4.ensureDir(path5.dirname(destPath));
-          await fs4.copy(srcPath, destPath, { overwrite: true });
+          await fs5.ensureDir(path6.dirname(destPath));
+          await fs5.copy(srcPath, destPath, { overwrite: true });
           result.replaced.push(file);
           processedFiles.add(file);
         } catch (err) {
@@ -642,21 +930,21 @@ async function applyFileCategories(sourceDir, destDir, versionJson) {
           processedFiles.add(file);
           continue;
         }
-        const srcPath = path5.join(sourceDir, file);
-        const destPath = path5.join(destDir, file);
+        const srcPath = path6.join(sourceDir, file);
+        const destPath = path6.join(destDir, file);
         try {
-          const destExists = await fs4.pathExists(destPath);
+          const destExists = await fs5.pathExists(destPath);
           if (destExists && file.endsWith(".json")) {
-            const incoming = await fs4.readJson(srcPath);
-            const existing = await fs4.readJson(destPath);
+            const incoming = await fs5.readJson(srcPath);
+            const existing = await fs5.readJson(destPath);
             const merged = merge({}, incoming, existing);
-            await fs4.writeJson(destPath, merged, { spaces: 2 });
+            await fs5.writeJson(destPath, merged, { spaces: 2 });
             result.merged.push(file);
           } else if (destExists) {
             result.skipped.push(file);
           } else {
-            await fs4.ensureDir(path5.dirname(destPath));
-            await fs4.copy(srcPath, destPath);
+            await fs5.ensureDir(path6.dirname(destPath));
+            await fs5.copy(srcPath, destPath);
             result.replaced.push(file);
           }
           processedFiles.add(file);
@@ -685,13 +973,13 @@ async function applyFileCategories(sourceDir, destDir, versionJson) {
           processedFiles.add(file);
           continue;
         }
-        const srcPath = path5.join(sourceDir, file);
-        const destPath = path5.join(destDir, file);
+        const srcPath = path6.join(sourceDir, file);
+        const destPath = path6.join(destDir, file);
         try {
-          const destExists = await fs4.pathExists(destPath);
+          const destExists = await fs5.pathExists(destPath);
           if (!destExists) {
-            await fs4.ensureDir(path5.dirname(destPath));
-            await fs4.copy(srcPath, destPath);
+            await fs5.ensureDir(path6.dirname(destPath));
+            await fs5.copy(srcPath, destPath);
             result.added.push(file);
           } else {
             result.skipped.push(file);
@@ -712,8 +1000,8 @@ function matchesPattern(filePath, pattern) {
 }
 async function isGitRepo(dirPath) {
   try {
-    const gitDir = path5.join(dirPath, ".git");
-    return await fs4.pathExists(gitDir);
+    const gitDir = path6.join(dirPath, ".git");
+    return await fs5.pathExists(gitDir);
   } catch {
     return false;
   }
@@ -741,16 +1029,28 @@ async function createGitBackup(dirPath, message) {
 
 // src/commands/upgrade.ts
 async function upgrade(options) {
-  p4.intro(pc5.cyan("aiorg upgrade"));
+  p5.intro(pc6.cyan("aiorg upgrade"));
   const kit = await detectKitInCwd();
   if (!kit) {
     error("Not in a kit directory");
-    log(pc5.dim("Run this command from a folder with .claude/version.json"));
+    log(pc6.dim("Run this command from a folder with .claude/version.json"));
     process.exit(1);
   }
-  keyValue("Kit", pc5.magenta(kit.displayName));
-  keyValue("Current version", pc5.cyan(`v${kit.version}`));
-  const spinner4 = p4.spinner();
+  keyValue("Kit", pc6.magenta(kit.displayName));
+  keyValue("Current version", pc6.cyan(`v${kit.version}`));
+  if (await needsProjectMigration(kit.rootPath)) {
+    const projectName = await migrateToProjectSystem(kit.rootPath, kit.name);
+    if (!projectName) {
+      blank();
+      log(pc6.dim("Skipping project setup. You can run it later."));
+    }
+  } else {
+    const aiorgFile = await readAiorgFile(kit.rootPath);
+    if (aiorgFile) {
+      await addKitToProject(aiorgFile.project, kit.name);
+    }
+  }
+  const spinner4 = p5.spinner();
   spinner4.start("Checking for updates...");
   let latest;
   try {
@@ -762,13 +1062,13 @@ async function upgrade(options) {
   }
   if (!semver.gt(latest.version, kit.version)) {
     blank();
-    success(`Already on latest version (${pc5.cyan(`v${kit.version}`)})`);
-    p4.outro("");
+    success(`Already on latest version (${pc6.cyan(`v${kit.version}`)})`);
+    p5.outro("");
     return;
   }
   blank();
   log(
-    `Update available: ${pc5.cyan(`v${kit.version}`)} \u2192 ${pc5.green(`v${latest.version}`)}`
+    `Update available: ${pc6.cyan(`v${kit.version}`)} \u2192 ${pc6.green(`v${latest.version}`)}`
   );
   if (latest.allVersions && Array.isArray(latest.allVersions)) {
     const versionsToShow = latest.allVersions.filter((v) => {
@@ -790,17 +1090,17 @@ async function upgrade(options) {
         if (!entry) continue;
         const highlights = entry.highlights?.join(", ") || "";
         blank();
-        log(`${pc5.green(`v${version2}`)}${highlights ? ` - ${pc5.white(highlights)}` : ""}`);
+        log(`${pc6.green(`v${version2}`)}${highlights ? ` - ${pc6.white(highlights)}` : ""}`);
         if (entry.added && entry.added.length > 0) {
           for (const item of entry.added.slice(0, 2)) {
-            log(pc5.dim(`  + ${item}`));
+            log(pc6.dim(`  + ${item}`));
           }
           if (entry.added.length > 2) {
-            log(pc5.dim(`  + ... and ${entry.added.length - 2} more`));
+            log(pc6.dim(`  + ... and ${entry.added.length - 2} more`));
           }
         }
         if (entry.upgradeNotes && version2 === latest.version) {
-          log(pc5.yellow(`  Note: ${entry.upgradeNotes}`));
+          log(pc6.yellow(`  Note: ${entry.upgradeNotes}`));
         }
       }
     }
@@ -809,19 +1109,19 @@ async function upgrade(options) {
   log("Your data will be preserved:");
   const neverTouch = kit.versionJson.fileCategories?.neverTouch ?? [];
   for (const pattern of neverTouch.slice(0, 5)) {
-    listItem(pc5.dim(pattern));
+    listItem(pc6.dim(pattern));
   }
   if (neverTouch.length > 5) {
-    log(pc5.dim(`  ... and ${neverTouch.length - 5} more patterns`));
+    log(pc6.dim(`  ... and ${neverTouch.length - 5} more patterns`));
   }
   if (!options.yes) {
     blank();
-    const shouldUpgrade = await p4.confirm({
+    const shouldUpgrade = await p5.confirm({
       message: "Proceed with upgrade?",
       initialValue: true
     });
-    if (p4.isCancel(shouldUpgrade) || !shouldUpgrade) {
-      p4.cancel("Upgrade cancelled");
+    if (p5.isCancel(shouldUpgrade) || !shouldUpgrade) {
+      p5.cancel("Upgrade cancelled");
       return;
     }
   }
@@ -850,7 +1150,7 @@ async function upgrade(options) {
       );
       spinner4.stop(created ? "Git backup created" : "No changes to backup");
     } else if (!options.yes) {
-      const shouldBackup = await p4.confirm({
+      const shouldBackup = await p5.confirm({
         message: "Create git backup commit first?",
         initialValue: true
       });
@@ -881,8 +1181,8 @@ async function upgrade(options) {
   let tempDir = null;
   try {
     tempDir = await createTempDir("aiorg-upgrade-");
-    const zipPath = path6.join(tempDir, "kit.zip");
-    const extractPath = path6.join(tempDir, "extracted");
+    const zipPath = path7.join(tempDir, "kit.zip");
+    const extractPath = path7.join(tempDir, "extracted");
     const zipData = await downloadFile(downloadInfo.downloadUrl);
     await saveToFile(zipData, zipPath);
     const sizeKB = await getFileSizeKB(zipPath);
@@ -903,7 +1203,7 @@ async function upgrade(options) {
     spinner4.stop("Updates applied");
     blank();
     success(
-      `Upgraded ${kit.displayName}: ${pc5.cyan(`v${kit.version}`)} \u2192 ${pc5.green(`v${latest.version}`)}`
+      `Upgraded ${kit.displayName}: ${pc6.cyan(`v${kit.version}`)} \u2192 ${pc6.green(`v${latest.version}`)}`
     );
     blank();
     keyValue("Files updated", String(result.replaced.length));
@@ -918,7 +1218,7 @@ async function upgrade(options) {
       blank();
       warn(`${result.errors.length} errors occurred:`);
       for (const err of result.errors) {
-        listItem(pc5.dim(err));
+        listItem(pc6.dim(err));
       }
     }
     await cleanupTempDir(tempDir);
@@ -929,46 +1229,46 @@ async function upgrade(options) {
     throw error2;
   }
   blank();
-  log(pc5.yellow("\u26A0\uFE0F  Restart Claude Code to use new commands"));
-  log(pc5.dim('   Type "exit" then start a new session'));
-  p4.outro(pc5.green("Upgrade complete!"));
+  log(pc6.yellow("\u26A0\uFE0F  Restart Claude Code to use new commands"));
+  log(pc6.dim('   Type "exit" then start a new session'));
+  p5.outro(pc6.green("Upgrade complete!"));
 }
 
 // src/commands/version.ts
-import pc6 from "picocolors";
+import pc7 from "picocolors";
 import semver2 from "semver";
 var CLI_VERSION = "1.0.0";
 async function version() {
   header("aiorg version");
-  keyValue("CLI", pc6.cyan(`v${CLI_VERSION}`));
+  keyValue("CLI", pc7.cyan(`v${CLI_VERSION}`));
   const kit = await detectKitInCwd();
   if (!kit) {
     blank();
     info("No kit detected in current directory");
-    log(pc6.dim("Run this command from a folder containing a kit"));
+    log(pc7.dim("Run this command from a folder containing a kit"));
     return;
   }
-  keyValue(kit.displayName, pc6.cyan(`v${kit.version}`));
+  keyValue(kit.displayName, pc7.cyan(`v${kit.version}`));
   try {
     const latest = await fetchLatestVersion(kit.name);
     if (semver2.gt(latest.version, kit.version)) {
       blank();
       warn(
-        `Update available: ${pc6.cyan(`v${kit.version}`)} \u2192 ${pc6.green(`v${latest.version}`)}`
+        `Update available: ${pc7.cyan(`v${kit.version}`)} \u2192 ${pc7.green(`v${latest.version}`)}`
       );
-      log(pc6.dim("Run 'aiorg upgrade' to update"));
+      log(pc7.dim("Run 'aiorg upgrade' to update"));
     } else {
       blank();
       success("You are on the latest version");
     }
   } catch {
     blank();
-    log(pc6.dim("Could not check for updates"));
+    log(pc7.dim("Could not check for updates"));
   }
 }
 
 // src/commands/list.ts
-import pc7 from "picocolors";
+import pc8 from "picocolors";
 function formatPrice(cents) {
   if (cents === 0) return "";
   return `$${(cents / 100).toFixed(0)}`;
@@ -982,44 +1282,137 @@ async function list() {
   const freeKits = kits.filter((k) => k.tier === "free");
   const paidKits = kits.filter((k) => k.tier === "paid");
   blank();
-  console.log(pc7.bold("Available Kits"));
+  console.log(pc8.bold("Available Kits"));
   blank();
   if (freeKits.length > 0) {
-    console.log(pc7.green(pc7.bold("FREE")));
+    console.log(pc8.green(pc8.bold("FREE")));
     blank();
     for (const kit of freeKits) {
       printKit(kit);
     }
   }
   if (paidKits.length > 0) {
-    console.log(pc7.yellow(pc7.bold("PAID")));
+    console.log(pc8.yellow(pc8.bold("PAID")));
     blank();
     for (const kit of paidKits) {
       printKit(kit);
     }
   }
-  console.log(pc7.dim("\u2500".repeat(50)));
+  console.log(pc8.dim("\u2500".repeat(50)));
   blank();
-  console.log(pc7.dim("Free kits work without login."));
-  console.log(pc7.dim(`Run '${pc7.cyan("aiorg login")}' first for paid kits.`));
-  console.log(pc7.dim(`Visit ${pc7.cyan("https://aiorg.dev")} for details.`));
+  console.log(pc8.dim("Free kits work without login."));
+  console.log(pc8.dim(`Run '${pc8.cyan("aiorg login")}' first for paid kits.`));
+  console.log(pc8.dim(`Visit ${pc8.cyan("https://aiorg.dev")} for details.`));
   blank();
 }
 function printKit(kit) {
   const price = formatPrice(kit.priceCents);
-  const priceStr = price ? pc7.yellow(price) : "";
+  const priceStr = price ? pc8.yellow(price) : "";
   console.log(
-    `  ${pc7.bold(kit.name.padEnd(24))} ${pc7.cyan(`v${kit.version}`)}  ${priceStr}`
+    `  ${pc8.bold(kit.name.padEnd(24))} ${pc8.cyan(`v${kit.version}`)}  ${priceStr}`
   );
   if (kit.description) {
-    console.log(`  ${pc7.dim(kit.description)}`);
+    console.log(`  ${pc8.dim(kit.description)}`);
   }
   console.log(
-    `  ${pc7.dim("\u2192")} ${pc7.dim("npx @aiorg/cli init")} ${pc7.magenta(kit.name)} ${pc7.dim("~/my-project")}`
+    `  ${pc8.dim("\u2192")} ${pc8.dim("npx @aiorg/cli init")} ${pc8.magenta(kit.name)} ${pc8.dim("~/my-project")}`
   );
   blank();
 }
 
+// src/commands/status.ts
+import * as p6 from "@clack/prompts";
+import pc9 from "picocolors";
+async function status() {
+  p6.intro(pc9.cyan("aiorg status"));
+  const kit = await detectKitInCwd();
+  const aiorgFile = await readAiorgFile(process.cwd());
+  if (!kit && !aiorgFile) {
+    const projects = await listProjects();
+    if (projects.length === 0) {
+      info("No AI Org projects found");
+      blank();
+      log(pc9.dim("Get started with:"));
+      listItem("npx @aiorg/cli init <kit-name> <path>");
+      p6.outro("");
+      return;
+    }
+    header("Your Projects");
+    for (const projectName of projects) {
+      const context = await readProjectContext(projectName);
+      if (context) {
+        blank();
+        log(pc9.cyan(projectName));
+        if (context.business?.name) {
+          log(pc9.dim(`  Business: ${context.business.name}`));
+        }
+        if (context.business?.stage) {
+          log(pc9.dim(`  Stage: ${context.business.stage}`));
+        }
+        if (context.installedKits && context.installedKits.length > 0) {
+          log(pc9.dim(`  Kits: ${context.installedKits.join(", ")}`));
+        }
+        if (context.pmf?.status && context.pmf.status !== "not-started") {
+          log(pc9.dim(`  PMF: ${context.pmf.status}`));
+        }
+      } else {
+        blank();
+        log(pc9.cyan(projectName));
+        log(pc9.dim("  (no context)"));
+      }
+    }
+    blank();
+    log(pc9.dim(`Projects stored in: ~/.aiorg/projects/`));
+    p6.outro("");
+    return;
+  }
+  if (kit) {
+    keyValue("Kit", pc9.magenta(kit.displayName));
+    keyValue("Version", pc9.cyan(`v${kit.version}`));
+  }
+  if (aiorgFile) {
+    keyValue("Project", pc9.cyan(aiorgFile.project));
+    const context = await readProjectContext(aiorgFile.project);
+    if (context) {
+      blank();
+      header("Project Context");
+      if (context.business?.name) {
+        keyValue("Business", context.business.name);
+      }
+      if (context.business?.stage) {
+        keyValue("Stage", context.business.stage);
+      }
+      if (context.validation?.ideaValidated) {
+        keyValue("Idea Validated", pc9.green("Yes"));
+        if (context.validation.ideaScore) {
+          keyValue("Idea Score", `${context.validation.ideaScore}/100`);
+        }
+      }
+      if (context.pmf?.status && context.pmf.status !== "not-started") {
+        const pmfColor = context.pmf.status === "achieved" ? pc9.green : pc9.yellow;
+        keyValue("PMF Status", pmfColor(context.pmf.status));
+        if (context.pmf.score !== null && context.pmf.score !== void 0) {
+          keyValue("PMF Score", `${context.pmf.score}/100`);
+        }
+      }
+      if (context.installedKits && context.installedKits.length > 0) {
+        blank();
+        log(pc9.dim("Installed kits:"));
+        for (const kitName of context.installedKits) {
+          listItem(kitName);
+        }
+      }
+      blank();
+      log(pc9.dim(`Context: ~/.aiorg/projects/${aiorgFile.project}/`));
+    }
+  } else if (kit) {
+    blank();
+    warn("Not linked to a project");
+    log(pc9.dim("Run upgrade to set up project linking"));
+  }
+  p6.outro("");
+}
+
 // src/index.ts
 var cli = cac("aiorg");
 cli.command("login", "Save your license key").action(async () => {
@@ -1038,9 +1431,9 @@ cli.command("logout", "Remove saved license key").action(async () => {
     process.exit(1);
   }
 });
-cli.command("init <kit> [path]", "Download and extract a kit").option("--force", "Overwrite existing folder").action(async (kit, path7, options) => {
+cli.command("init <kit> [path]", "Download and extract a kit").option("--force", "Overwrite existing folder").action(async (kit, path8, options) => {
   try {
-    await init(kit, path7, options);
+    await init(kit, path8, options);
   } catch (error2) {
     error(error2 instanceof Error ? error2.message : "Init failed");
     process.exit(1);
@@ -1070,6 +1463,14 @@ cli.command("version", "Show CLI and kit versions").action(async () => {
     process.exit(1);
   }
 });
+cli.command("status", "Show project and kit status").action(async () => {
+  try {
+    await status();
+  } catch (error2) {
+    error(error2 instanceof Error ? error2.message : "Status check failed");
+    process.exit(1);
+  }
+});
 cli.help();
 cli.version("1.0.0");
 cli.parse();