ccjk 2.0.20 → 2.2.1

package/dist/chunks/onboarding.mjs

@@ -0,0 +1,711 @@
+import { existsSync, readFileSync, readdirSync, mkdirSync, statSync } from 'node:fs';
+import process from 'node:process';
+import ansis from 'ansis';
+import dayjs from 'dayjs';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { join, basename } from 'pathe';
+import { CCJK_CONFIG_DIR } from './constants.mjs';
+import { b as boxify, C as COLORS, S as STATUS } from '../shared/ccjk.BhKlRJ0h.mjs';
+import { writeFileAtomic } from './fs-operations.mjs';
+
+function readPackageJson(dir) {
+  const pkgPath = join(dir, "package.json");
+  if (!existsSync(pkgPath))
+    return null;
+  try {
+    return JSON.parse(readFileSync(pkgPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function detectPackageManager(dir) {
+  if (existsSync(join(dir, "bun.lockb")))
+    return "bun";
+  if (existsSync(join(dir, "pnpm-lock.yaml")))
+    return "pnpm";
+  if (existsSync(join(dir, "yarn.lock")))
+    return "yarn";
+  if (existsSync(join(dir, "package-lock.json")))
+    return "npm";
+  const pkg = readPackageJson(dir);
+  if (pkg?.packageManager) {
+    if (pkg.packageManager.startsWith("pnpm"))
+      return "pnpm";
+    if (pkg.packageManager.startsWith("yarn"))
+      return "yarn";
+    if (pkg.packageManager.startsWith("bun"))
+      return "bun";
+  }
+  return "unknown";
+}
+function detectFrameworks(dir) {
+  const frameworks = [];
+  const pkg = readPackageJson(dir);
+  if (!pkg)
+    return frameworks;
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  if (allDeps.react)
+    frameworks.push("react");
+  if (allDeps.vue)
+    frameworks.push("vue");
+  if (allDeps["@angular/core"])
+    frameworks.push("angular");
+  if (allDeps.svelte)
+    frameworks.push("svelte");
+  if (allDeps.next)
+    frameworks.push("nextjs");
+  if (allDeps.nuxt)
+    frameworks.push("nuxt");
+  if (allDeps["@remix-run/react"])
+    frameworks.push("remix");
+  if (allDeps.astro)
+    frameworks.push("astro");
+  if (allDeps.express)
+    frameworks.push("express");
+  if (allDeps.fastify)
+    frameworks.push("fastify");
+  if (allDeps["@nestjs/core"])
+    frameworks.push("nestjs");
+  if (allDeps.koa)
+    frameworks.push("koa");
+  if (allDeps.hono)
+    frameworks.push("hono");
+  if (allDeps.electron)
+    frameworks.push("electron");
+  if (allDeps["@tauri-apps/api"])
+    frameworks.push("tauri");
+  if (allDeps["react-native"])
+    frameworks.push("react-native");
+  if (existsSync(join(dir, "requirements.txt")) || existsSync(join(dir, "pyproject.toml"))) {
+    const reqPath = join(dir, "requirements.txt");
+    if (existsSync(reqPath)) {
+      const reqs = readFileSync(reqPath, "utf-8").toLowerCase();
+      if (reqs.includes("django"))
+        frameworks.push("django");
+      if (reqs.includes("flask"))
+        frameworks.push("flask");
+      if (reqs.includes("fastapi"))
+        frameworks.push("fastapi");
+    }
+  }
+  if (existsSync(join(dir, "Gemfile"))) {
+    const gemfile = readFileSync(join(dir, "Gemfile"), "utf-8").toLowerCase();
+    if (gemfile.includes("rails"))
+      frameworks.push("rails");
+  }
+  if (existsSync(join(dir, "composer.json"))) {
+    try {
+      const composer = JSON.parse(readFileSync(join(dir, "composer.json"), "utf-8"));
+      if (composer.require?.["laravel/framework"])
+        frameworks.push("laravel");
+    } catch {
+    }
+  }
+  return frameworks;
+}
+function detectBuildTools(dir) {
+  const tools = [];
+  const pkg = readPackageJson(dir);
+  if (existsSync(join(dir, "vite.config.ts")) || existsSync(join(dir, "vite.config.js")))
+    tools.push("vite");
+  if (existsSync(join(dir, "webpack.config.js")) || existsSync(join(dir, "webpack.config.ts")))
+    tools.push("webpack");
+  if (existsSync(join(dir, "rollup.config.js")) || existsSync(join(dir, "rollup.config.ts")))
+    tools.push("rollup");
+  if (existsSync(join(dir, "tsup.config.ts")) || existsSync(join(dir, "tsup.config.js")))
+    tools.push("tsup");
+  if (pkg) {
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (allDeps.esbuild)
+      tools.push("esbuild");
+    if (allDeps["@swc/core"])
+      tools.push("swc");
+    if (allDeps.turbo)
+      tools.push("turbopack");
+    if (allDeps.parcel)
+      tools.push("parcel");
+    if (allDeps.unbuild)
+      tools.push("unbuild");
+  }
+  return tools;
+}
+function detectTestFrameworks(dir) {
+  const frameworks = [];
+  const pkg = readPackageJson(dir);
+  if (existsSync(join(dir, "vitest.config.ts")) || existsSync(join(dir, "vitest.config.js")))
+    frameworks.push("vitest");
+  if (existsSync(join(dir, "jest.config.js")) || existsSync(join(dir, "jest.config.ts")))
+    frameworks.push("jest");
+  if (existsSync(join(dir, "cypress.config.ts")) || existsSync(join(dir, "cypress.config.js")))
+    frameworks.push("cypress");
+  if (existsSync(join(dir, "playwright.config.ts")))
+    frameworks.push("playwright");
+  if (existsSync(join(dir, "pytest.ini")) || existsSync(join(dir, "conftest.py")))
+    frameworks.push("pytest");
+  if (pkg) {
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (allDeps.vitest && !frameworks.includes("vitest"))
+      frameworks.push("vitest");
+    if (allDeps.jest && !frameworks.includes("jest"))
+      frameworks.push("jest");
+    if (allDeps.mocha)
+      frameworks.push("mocha");
+    if (allDeps.cypress && !frameworks.includes("cypress"))
+      frameworks.push("cypress");
+    if (allDeps["@playwright/test"] && !frameworks.includes("playwright"))
+      frameworks.push("playwright");
+  }
+  return frameworks;
+}
+function detectCICDSystems(dir) {
+  const systems = [];
+  if (existsSync(join(dir, ".github", "workflows")))
+    systems.push("github-actions");
+  if (existsSync(join(dir, ".gitlab-ci.yml")))
+    systems.push("gitlab-ci");
+  if (existsSync(join(dir, "Jenkinsfile")))
+    systems.push("jenkins");
+  if (existsSync(join(dir, ".circleci")))
+    systems.push("circleci");
+  if (existsSync(join(dir, ".travis.yml")))
+    systems.push("travis");
+  if (existsSync(join(dir, "azure-pipelines.yml")))
+    systems.push("azure-pipelines");
+  return systems;
+}
+function detectLanguages(dir) {
+  const languages = [];
+  if (existsSync(join(dir, "tsconfig.json")))
+    languages.push("typescript");
+  if (existsSync(join(dir, "package.json"))) {
+    if (!languages.includes("typescript"))
+      languages.push("javascript");
+  }
+  if (existsSync(join(dir, "requirements.txt")) || existsSync(join(dir, "pyproject.toml")) || existsSync(join(dir, "setup.py")))
+    languages.push("python");
+  if (existsSync(join(dir, "Gemfile")))
+    languages.push("ruby");
+  if (existsSync(join(dir, "go.mod")))
+    languages.push("go");
+  if (existsSync(join(dir, "Cargo.toml")))
+    languages.push("rust");
+  if (existsSync(join(dir, "pom.xml")) || existsSync(join(dir, "build.gradle"))) {
+    languages.push("java");
+    if (existsSync(join(dir, "build.gradle.kts")))
+      languages.push("kotlin");
+  }
+  if (existsSync(join(dir, "composer.json")))
+    languages.push("php");
+  if (existsSync(join(dir, "Package.swift")))
+    languages.push("swift");
+  if (existsSync(join(dir, "pubspec.yaml")))
+    languages.push("dart");
+  return languages;
+}
+function determineProjectType(info) {
+  const frameworks = info.frameworks || [];
+  if (frameworks.includes("react-native") || frameworks.includes("flutter"))
+    return "mobile";
+  if (frameworks.includes("electron") || frameworks.includes("tauri"))
+    return "desktop";
+  const pkg = info.rootDir ? readPackageJson(info.rootDir) : null;
+  if (pkg?.bin)
+    return "cli";
+  if (pkg?.main || pkg?.exports) {
+    const hasAppFramework = frameworks.some(
+      (f) => ["react", "vue", "angular", "svelte", "nextjs", "nuxt", "express", "fastify", "nestjs"].includes(f)
+    );
+    if (!hasAppFramework)
+      return "library";
+  }
+  const frontendFrameworks = ["react", "vue", "angular", "svelte"];
+  const backendFrameworks = ["express", "fastify", "nestjs", "koa", "hono", "django", "flask", "fastapi", "rails", "laravel"];
+  const metaFrameworks = ["nextjs", "nuxt", "remix", "astro"];
+  const hasFrontend = frameworks.some((f) => frontendFrameworks.includes(f));
+  const hasBackend = frameworks.some((f) => backendFrameworks.includes(f));
+  const hasMeta = frameworks.some((f) => metaFrameworks.includes(f));
+  if (hasMeta)
+    return "fullstack";
+  if (hasFrontend && hasBackend)
+    return "fullstack";
+  if (hasFrontend)
+    return "frontend";
+  if (hasBackend)
+    return "backend";
+  return "unknown";
+}
+function detectProject(dir = process.cwd()) {
+  const pkg = readPackageJson(dir);
+  const frameworks = detectFrameworks(dir);
+  const languages = detectLanguages(dir);
+  const info = {
+    name: pkg?.name || "unknown",
+    type: "unknown",
+    packageManager: detectPackageManager(dir),
+    frameworks,
+    buildTools: detectBuildTools(dir),
+    testFrameworks: detectTestFrameworks(dir),
+    cicd: detectCICDSystems(dir),
+    languages,
+    hasTypeScript: existsSync(join(dir, "tsconfig.json")),
+    hasDocker: existsSync(join(dir, "Dockerfile")) || existsSync(join(dir, "docker-compose.yml")),
+    hasMonorepo: existsSync(join(dir, "pnpm-workspace.yaml")) || existsSync(join(dir, "lerna.json")) || pkg?.workspaces != null,
+    rootDir: dir
+  };
+  info.type = determineProjectType(info);
+  return info;
+}
+function generateSuggestions(project) {
+  const suggestions = {
+    workflows: ["git"],
+    mcpServices: [],
+    agents: [],
+    skills: [],
+    subagentGroups: [],
+    outputStyle: "technical-precise"
+  };
+  if (project.hasTypeScript || project.languages.includes("typescript")) {
+    suggestions.subagentGroups.push("typescript-dev");
+    suggestions.skills.push("ts-debug", "ts-refactor", "ts-test");
+  }
+  if (project.languages.includes("python")) {
+    suggestions.subagentGroups.push("python-dev");
+    suggestions.skills.push("py-debug", "py-refactor", "py-test");
+  }
+  if (project.frameworks.includes("nextjs") || project.frameworks.includes("nuxt")) {
+    suggestions.workflows.push("frontend", "testing");
+    suggestions.agents.push("ccjk-performance-expert");
+  }
+  if (project.frameworks.includes("express") || project.frameworks.includes("fastify") || project.frameworks.includes("nestjs")) {
+    suggestions.workflows.push("backend", "testing");
+    suggestions.agents.push("ccjk-security-expert");
+  }
+  if (project.hasDocker || project.cicd.length > 0) {
+    suggestions.workflows.push("devops");
+    suggestions.subagentGroups.push("devops-team");
+    suggestions.skills.push("devops-docker", "devops-ci");
+  }
+  if (project.testFrameworks.length > 0) {
+    suggestions.workflows.push("testing");
+    suggestions.agents.push("ccjk-testing-specialist");
+  }
+  if (project.hasMonorepo) {
+    suggestions.agents.push("ccjk-code-reviewer");
+  }
+  if (project.type === "frontend" || project.type === "fullstack") {
+    suggestions.subagentGroups.push("seo-team");
+    suggestions.skills.push("seo-meta", "seo-schema");
+  }
+  suggestions.subagentGroups.push("security-team");
+  suggestions.workflows = [...new Set(suggestions.workflows)];
+  suggestions.agents = [...new Set(suggestions.agents)];
+  suggestions.skills = [...new Set(suggestions.skills)];
+  suggestions.subagentGroups = [...new Set(suggestions.subagentGroups)];
+  return suggestions;
+}
+function getProjectSummary(project) {
+  const parts = [];
+  parts.push(`Project: ${project.name}`);
+  parts.push(`Type: ${project.type}`);
+  if (project.languages.length > 0) {
+    parts.push(`Languages: ${project.languages.join(", ")}`);
+  }
+  if (project.frameworks.length > 0) {
+    parts.push(`Frameworks: ${project.frameworks.join(", ")}`);
+  }
+  if (project.buildTools.length > 0) {
+    parts.push(`Build: ${project.buildTools.join(", ")}`);
+  }
+  if (project.testFrameworks.length > 0) {
+    parts.push(`Testing: ${project.testFrameworks.join(", ")}`);
+  }
+  parts.push(`Package Manager: ${project.packageManager}`);
+  const features = [];
+  if (project.hasTypeScript)
+    features.push("TypeScript");
+  if (project.hasDocker)
+    features.push("Docker");
+  if (project.hasMonorepo)
+    features.push("Monorepo");
+  if (features.length > 0) {
+    parts.push(`Features: ${features.join(", ")}`);
+  }
+  return parts.join("\n");
+}
+
+const KNOWLEDGE_BASE_FILE = join(CCJK_CONFIG_DIR, "knowledge-base.json");
+function simpleHash(content) {
+  let hash = 0;
+  for (let i = 0; i < content.length; i++) {
+    const char = content.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return hash.toString(16);
+}
+function loadKnowledgeBase() {
+  if (existsSync(KNOWLEDGE_BASE_FILE)) {
+    try {
+      return JSON.parse(readFileSync(KNOWLEDGE_BASE_FILE, "utf-8"));
+    } catch {
+    }
+  }
+  return {
+    version: "1.0.0",
+    lastSync: (/* @__PURE__ */ new Date()).toISOString(),
+    entries: [],
+    projectContexts: []
+  };
+}
+function saveKnowledgeBase(kb) {
+  if (!existsSync(CCJK_CONFIG_DIR)) {
+    mkdirSync(CCJK_CONFIG_DIR, { recursive: true });
+  }
+  kb.lastSync = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileAtomic(KNOWLEDGE_BASE_FILE, JSON.stringify(kb, null, 2));
+}
+function isFileOutdated(filePath, daysThreshold = 30) {
+  try {
+    const stat = statSync(filePath);
+    const daysSinceModified = dayjs().diff(dayjs(stat.mtime), "day");
+    return daysSinceModified > daysThreshold;
+  } catch {
+    return true;
+  }
+}
+function scanClaudeMd(projectDir) {
+  const possiblePaths = [
+    join(projectDir, "CLAUDE.md"),
+    join(projectDir, "claude.md"),
+    join(projectDir, ".claude", "CLAUDE.md"),
+    join(projectDir, "docs", "CLAUDE.md")
+  ];
+  for (const path of possiblePaths) {
+    if (existsSync(path)) {
+      const content = readFileSync(path, "utf-8");
+      return {
+        path,
+        content,
+        outdated: isFileOutdated(path)
+      };
+    }
+  }
+  return null;
+}
+function scanAgents(projectDir) {
+  const agents = [];
+  const agentDirs = [
+    join(projectDir, ".claude", "agents"),
+    join(projectDir, "agents"),
+    join(projectDir, ".agents")
+  ];
+  for (const dir of agentDirs) {
+    if (existsSync(dir)) {
+      try {
+        const files = readdirSync(dir);
+        for (const file of files) {
+          if (file.endsWith(".md")) {
+            const filePath = join(dir, file);
+            agents.push({
+              path: filePath,
+              name: basename(file, ".md"),
+              content: readFileSync(filePath, "utf-8")
+            });
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return agents;
+}
+function scanSkills(projectDir) {
+  const skills = [];
+  const skillDirs = [
+    join(projectDir, ".claude", "commands"),
+    join(projectDir, ".claude", "skills"),
+    join(projectDir, "skills")
+  ];
+  for (const dir of skillDirs) {
+    if (existsSync(dir)) {
+      try {
+        const files = readdirSync(dir);
+        for (const file of files) {
+          if (file.endsWith(".md")) {
+            const filePath = join(dir, file);
+            skills.push({
+              path: filePath,
+              name: basename(file, ".md"),
+              content: readFileSync(filePath, "utf-8")
+            });
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return skills;
+}
+function addToKnowledgeBase(kb, type, name, path, content, projectRoot) {
+  const hash = simpleHash(content);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existingIndex = kb.entries.findIndex((e) => e.path === path);
+  if (existingIndex >= 0) {
+    if (kb.entries[existingIndex].hash !== hash) {
+      kb.entries[existingIndex] = {
+        ...kb.entries[existingIndex],
+        content,
+        hash,
+        updatedAt: now
+      };
+    }
+  } else {
+    kb.entries.push({
+      id: `${type}-${Date.now()}`,
+      type,
+      name,
+      path,
+      content,
+      hash,
+      createdAt: now,
+      updatedAt: now,
+      projectRoot
+    });
+  }
+}
+function generateDefaultClaudeMd(project) {
+  return `# ${project.name}
+
+## Project Overview
+
+This is a ${project.type} project using ${project.frameworks.join(", ") || "standard tools"}.
+
+## Tech Stack
+
+${project.languages.map((l) => `- ${l}`).join("\n")}
+${project.frameworks.map((f) => `- ${f}`).join("\n")}
+
+## Development Guidelines
+
+### Code Style
+- Follow existing code conventions
+- Use TypeScript strict mode
+- Write meaningful commit messages
+
+### Testing
+${project.testFrameworks.length > 0 ? `Using: ${project.testFrameworks.join(", ")}` : "- Add tests for new features"}
+
+### Build & Deploy
+${project.buildTools.length > 0 ? `Build tools: ${project.buildTools.join(", ")}` : "- Follow standard build process"}
+
+## Important Files
+
+- \`README.md\` - Project documentation
+- \`package.json\` - Dependencies and scripts
+
+## AI Assistant Notes
+
+- Prefer concise, actionable responses
+- Follow existing patterns in the codebase
+- Ask before making breaking changes
+
+---
+*Generated by CCJK on ${dayjs().format("YYYY-MM-DD")}*
+`;
+}
+async function runOnboarding(projectDir = process.cwd()) {
+  console.log(boxify(`
+  Welcome to CCJK!
+
+  Let's set up your project for optimal AI-assisted development.
+  This will scan your project and create a knowledge base.
+`, "double", "\u{1F680} CCJK Setup"));
+  const result = {
+    success: false,
+    projectDetected: false,
+    claudeMdFound: false,
+    claudeMdUpdated: false,
+    agentsFound: 0,
+    skillsFound: 0,
+    knowledgeEntriesCreated: 0,
+    recommendations: []
+  };
+  const kb = loadKnowledgeBase();
+  const spinner = ora("Scanning project...").start();
+  const project = detectProject(projectDir);
+  spinner.succeed("Project detected");
+  result.projectDetected = true;
+  console.log("");
+  console.log(COLORS.secondary("\u{1F4C1} Project Info:"));
+  console.log(ansis.gray(getProjectSummary(project)));
+  console.log("");
+  spinner.start("Looking for CLAUDE.md...");
+  const claudeMd = scanClaudeMd(projectDir);
+  if (claudeMd) {
+    spinner.succeed(`Found CLAUDE.md at ${claudeMd.path}`);
+    result.claudeMdFound = true;
+    if (claudeMd.outdated) {
+      console.log(STATUS.warning("CLAUDE.md appears to be outdated (>30 days old)"));
+      const { updateClaudeMd } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "updateClaudeMd",
+          message: "Would you like to refresh it with current project info?",
+          default: true
+        }
+      ]);
+      if (updateClaudeMd) {
+        const newContent = generateDefaultClaudeMd(project);
+        const backupPath = `${claudeMd.path}.backup-${dayjs().format("YYYYMMDD")}`;
+        writeFileAtomic(backupPath, claudeMd.content);
+        writeFileAtomic(claudeMd.path, newContent);
+        console.log(STATUS.success(`Updated! Backup saved to ${backupPath}`));
+        result.claudeMdUpdated = true;
+        addToKnowledgeBase(kb, "claude-md", "CLAUDE.md", claudeMd.path, newContent, projectDir);
+      } else {
+        addToKnowledgeBase(kb, "claude-md", "CLAUDE.md", claudeMd.path, claudeMd.content, projectDir);
+      }
+    } else {
+      addToKnowledgeBase(kb, "claude-md", "CLAUDE.md", claudeMd.path, claudeMd.content, projectDir);
+    }
+    result.knowledgeEntriesCreated++;
+  } else {
+    spinner.warn("No CLAUDE.md found");
+    const { createClaudeMd } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "createClaudeMd",
+        message: "Would you like to create one? (Recommended for AI assistance)",
+        default: true
+      }
+    ]);
+    if (createClaudeMd) {
+      const newContent = generateDefaultClaudeMd(project);
+      const newPath = join(projectDir, "CLAUDE.md");
+      writeFileAtomic(newPath, newContent);
+      console.log(STATUS.success(`Created ${newPath}`));
+      result.claudeMdFound = true;
+      result.claudeMdUpdated = true;
+      addToKnowledgeBase(kb, "claude-md", "CLAUDE.md", newPath, newContent, projectDir);
+      result.knowledgeEntriesCreated++;
+    } else {
+      result.recommendations.push("Consider creating a CLAUDE.md file for better AI assistance");
+    }
+  }
+  spinner.start("Scanning for agents...");
+  const agents = scanAgents(projectDir);
+  spinner.succeed(`Found ${agents.length} agent(s)`);
+  result.agentsFound = agents.length;
+  for (const agent of agents) {
+    addToKnowledgeBase(kb, "agent", agent.name, agent.path, agent.content, projectDir);
+    result.knowledgeEntriesCreated++;
+  }
+  if (agents.length === 0) {
+    result.recommendations.push("Add custom agents in .claude/agents/ for specialized assistance");
+  }
+  spinner.start("Scanning for skills...");
+  const skills = scanSkills(projectDir);
+  spinner.succeed(`Found ${skills.length} skill(s)`);
+  result.skillsFound = skills.length;
+  for (const skill of skills) {
+    addToKnowledgeBase(kb, "skill", skill.name, skill.path, skill.content, projectDir);
+    result.knowledgeEntriesCreated++;
+  }
+  if (skills.length === 0) {
+    result.recommendations.push("Add custom skills in .claude/commands/ for quick actions");
+  }
+  const suggestions = generateSuggestions(project);
+  const existingContextIndex = kb.projectContexts.findIndex((c) => c.rootDir === projectDir);
+  const projectContext = {
+    rootDir: projectDir,
+    name: project.name,
+    type: project.type,
+    frameworks: project.frameworks,
+    lastScanned: (/* @__PURE__ */ new Date()).toISOString(),
+    claudeMdHash: claudeMd ? simpleHash(claudeMd.content) : void 0,
+    agentsCount: agents.length,
+    skillsCount: skills.length
+  };
+  if (existingContextIndex >= 0) {
+    kb.projectContexts[existingContextIndex] = projectContext;
+  } else {
+    kb.projectContexts.push(projectContext);
+  }
+  addToKnowledgeBase(
+    kb,
+    "project-info",
+    project.name,
+    projectDir,
+    JSON.stringify({ project, suggestions }, null, 2),
+    projectDir
+  );
+  result.knowledgeEntriesCreated++;
+  saveKnowledgeBase(kb);
+  console.log("");
+  console.log(COLORS.primary("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+  console.log(COLORS.accent("                 Setup Complete!                "));
+  console.log(COLORS.primary("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+  console.log("");
+  console.log(`  \u{1F4DA} Knowledge entries: ${result.knowledgeEntriesCreated}`);
+  console.log(`  \u{1F4C4} CLAUDE.md: ${result.claudeMdFound ? "\u2713" : "\u2717"}`);
+  console.log(`  \u{1F916} Agents: ${result.agentsFound}`);
+  console.log(`  \u26A1 Skills: ${result.skillsFound}`);
+  console.log("");
+  if (result.recommendations.length > 0) {
+    console.log(COLORS.secondary("\u{1F4A1} Recommendations:"));
+    for (const rec of result.recommendations) {
+      console.log(ansis.gray(`   \u2022 ${rec}`));
+    }
+    console.log("");
+  }
+  console.log(COLORS.secondary("\u{1F4CC} Next Steps:"));
+  console.log(ansis.gray("   \u2022 Run `ccjk` to open the main menu"));
+  console.log(ansis.gray("   \u2022 Run `ccjk doctor` to check environment"));
+  console.log(ansis.gray("   \u2022 Run `ccjk groups enable typescript-dev` for TypeScript support"));
+  console.log("");
+  result.success = true;
+  return result;
+}
+async function quickSync(projectDir = process.cwd()) {
+  const spinner = ora("Syncing project knowledge...").start();
+  const kb = loadKnowledgeBase();
+  detectProject(projectDir);
+  const claudeMd = scanClaudeMd(projectDir);
+  if (claudeMd) {
+    addToKnowledgeBase(kb, "claude-md", "CLAUDE.md", claudeMd.path, claudeMd.content, projectDir);
+  }
+  const agents = scanAgents(projectDir);
+  for (const agent of agents) {
+    addToKnowledgeBase(kb, "agent", agent.name, agent.path, agent.content, projectDir);
+  }
+  const skills = scanSkills(projectDir);
+  for (const skill of skills) {
+    addToKnowledgeBase(kb, "skill", skill.name, skill.path, skill.content, projectDir);
+  }
+  saveKnowledgeBase(kb);
+  spinner.succeed(`Synced: ${claudeMd ? 1 : 0} CLAUDE.md, ${agents.length} agents, ${skills.length} skills`);
+}
+function getProjectKnowledge(projectDir = process.cwd()) {
+  const kb = loadKnowledgeBase();
+  return kb.entries.filter((e) => e.projectRoot === projectDir);
+}
+function exportProjectKnowledge(projectDir = process.cwd()) {
+  const entries = getProjectKnowledge(projectDir);
+  return JSON.stringify(entries, null, 2);
+}
+
+const onboarding = {
+  __proto__: null,
+  exportProjectKnowledge: exportProjectKnowledge,
+  getProjectKnowledge: getProjectKnowledge,
+  loadKnowledgeBase: loadKnowledgeBase,
+  quickSync: quickSync,
+  runOnboarding: runOnboarding,
+  saveKnowledgeBase: saveKnowledgeBase
+};
+
+export { detectFrameworks as a, detectBuildTools as b, detectTestFrameworks as c, detectPackageManager as d, detectCICDSystems as e, detectLanguages as f, determineProjectType as g, detectProject as h, generateSuggestions as i, getProjectSummary as j, getProjectKnowledge as k, loadKnowledgeBase as l, exportProjectKnowledge as m, onboarding as o, quickSync as q, runOnboarding as r, saveKnowledgeBase as s };