@akanjs/cli 3.0.0-beta.3 → 3.0.0-beta.30

package/{index-fz5q3gd7.js → index-0ncc0mbk.js}

@@ -5,33 +5,26 @@ import {
   writeGeneratedSyncState,
   createRepairReport,
   renderRepairReport
-} from "./index-gyd220p2.js";
+} from "./index-hmdq5pqm.js";
 import {
   AkanContextAnalyzer
-} from "./index-ktb5njgy.js";
+} from "./index-tzc1gtrg.js";
 import {
   runner
-} from "./index-mak3cd28.js";
+} from "./index-xb7qhxa8.js";
 
 // pkgs/@akanjs/cli/repair/repair.runner.ts
-var commandForShell = (command) => command.startsWith("akan ") ? `bun run ${command}` : command;
+var spawnShell = async (workspace, command) => await workspace.spawn("bash", ["-lc", command.startsWith("akan ") ? `bun run ${command}` : command], {
+  cwd: workspace.workspaceRoot
+});
 var defaultExecutor = (workspace) => async (command) => {
+  const base = { command: command.command, reason: command.reason };
   try {
-    const stdout = await workspace.spawn("bash", ["-lc", commandForShell(command.command)], {
-      cwd: workspace.workspaceRoot
-    });
-    return {
-      command: command.command,
-      reason: command.reason,
-      status: "passed",
-      exitCode: 0,
-      stdout
-    };
+    return { ...base, status: "passed", exitCode: 0, stdout: await spawnShell(workspace, command.command) };
   } catch (error) {
     const commandError = error;
     return {
-      command: command.command,
-      reason: command.reason,
+      ...base,
       status: "failed",
       exitCode: commandError.code ?? 1,
       stdout: commandError.stdout,
@@ -158,4 +151,4 @@ class RepairRunner extends runner("repair") {
   }
 }
 
-export { RepairRunner };
+export { spawnShell, RepairRunner };

package/index-167c77aq.js

@@ -0,0 +1,69 @@
+// @bun
+import {
+  jsonText
+} from "./index-hmdq5pqm.js";
+import {
+  akanMcpInstallTargets
+} from "./index-tzc1gtrg.js";
+import {
+  script
+} from "./index-xb7qhxa8.js";
+import {
+  ContextRunner2
+} from "./index-hqd0h1pb.js";
+
+// pkgs/@akanjs/cli/context/context.script.ts
+import { Logger } from "akanjs/common";
+var resolveMcpInstallTargets = (target) => {
+  if (!target || target === "all")
+    return [...akanMcpInstallTargets];
+  if (akanMcpInstallTargets.includes(target))
+    return [target];
+  throw new Error(`Unknown MCP install target: ${target}. Use cursor, claude, codex, or all.`);
+};
+var mcpTargetLabels = {
+  cursor: "Cursor",
+  claude: "Claude Code",
+  codex: "Codex"
+};
+
+class ContextScript extends script("context", [ContextRunner2]) {
+  async context(workspace, options = {}) {
+    Logger.rawLog(await this.contextRunner.getContext(workspace, options));
+  }
+  async doctor(workspace, options = {}) {
+    Logger.rawLog(await this.contextRunner.doctor(workspace, options));
+  }
+  async mcpInstall(workspace, target, { force = false, mode = "apply" } = {}) {
+    const targets = resolveMcpInstallTargets(target);
+    const written = [];
+    for (const t of targets) {
+      const configPath = await this.contextRunner.installMcp(workspace, t, { force, mode });
+      written.push(`${mcpTargetLabels[t]}: ${configPath}`);
+    }
+    Logger.rawLog(`Akan MCP server installed (${mode} mode):
+${written.map((line) => `- ${line}`).join(`
+`)}`);
+  }
+  async mcp(workspace, { mode = "apply" } = {}) {
+    await this.contextRunner.runMcp(workspace, { mode });
+  }
+  async mcpCall(workspace, tool, {
+    mode = "readonly",
+    args = null,
+    format = "json"
+  } = {}) {
+    let parsedArgs = {};
+    if (args) {
+      const parsed = JSON.parse(args);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("MCP call args must be a JSON object.");
+      }
+      parsedArgs = parsed;
+    }
+    const result = await this.contextRunner.callMcpTool(workspace, tool, parsedArgs, { mode });
+    Logger.rawLog(format === "json" ? jsonText(result) : String(result));
+  }
+}
+
+export { ContextScript };

package/{index-kcxmv48c.js → index-2ahj896a.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
-  FileSys
-} from "./index-q0y2jq9j.js";
+  FileSys2
+} from "./index-52w0fvh8.js";
 
 // pkgs/@akanjs/devkit/dependencyScanner.ts
 import { builtinModules } from "module";
@@ -10,7 +10,10 @@ import ignore from "ignore";
 import ts from "typescript";
 var testFileRegex = /\.(?:test|spec)\.[cm]?[tj]sx?$/;
 var skipDirs = ["node_modules", "dist", "build", ".git", ".next", "public", "ios", "android", "__fixtures__"];
-var isSkippedPath = (filePath) => skipDirs.some((dir) => filePath.includes(`/${dir}/`) || filePath.startsWith(`${dir}/`));
+var isSkippedPath = (filePath) => {
+  const posixPath = filePath.split(path.sep).join("/");
+  return skipDirs.some((dir) => posixPath.includes(`/${dir}/`) || posixPath.startsWith(`${dir}/`));
+};
 var builtinModuleSet = new Set([...builtinModules, ...builtinModules.map((mod) => `node:${mod}`)]);
 var stripShebang = (source) => source.replace(/^#!.*(?:\r?\n|$)/, "");
 
@@ -54,24 +57,21 @@ class TypeScriptDependencyScanner2 {
   async getPackageBuildDependencies(projectName) {
     const runtimeDeps = new Set;
     const devDeps = new Set;
-    const sourceFiles = await this.#findTypeScriptFiles(this.#directory, {
-      excludeBuildFiles: true,
-      excludeTestFiles: true
-    });
-    const cssFiles = await this.#findCssFiles(this.#directory);
+    const sourceFiles = await this.#findFiles("**/*.{ts,tsx}", { excludeBuildFiles: true, excludeTestFiles: true });
+    const cssFiles = await this.#findFiles("**/*.css");
     for (const filePath of sourceFiles) {
-      const fileContent = await FileSys.readText(filePath);
+      const fileContent = await FileSys2.readText(filePath);
       const { imports, typeImports } = this.#extractImports(fileContent, filePath);
       this.#addNormalizedImports(runtimeDeps, imports, projectName);
       this.#addNormalizedImports(devDeps, typeImports, projectName);
     }
     for (const filePath of cssFiles) {
-      const fileContent = await FileSys.readText(filePath);
+      const fileContent = await FileSys2.readText(filePath);
       this.#addNormalizedImports(runtimeDeps, this.#extractCssPluginImports(fileContent), projectName);
     }
     const buildFilePath = path.join(this.#directory, "build.ts");
-    if (await FileSys.fileExists(buildFilePath)) {
-      const fileContent = await FileSys.readText(buildFilePath);
+    if (await FileSys2.fileExists(buildFilePath)) {
+      const fileContent = await FileSys2.readText(buildFilePath);
       const { imports, typeImports } = this.#extractImports(fileContent, buildFilePath);
       this.#addNormalizedImports(devDeps, [...imports, ...typeImports], projectName);
     }
@@ -95,7 +95,7 @@ class TypeScriptDependencyScanner2 {
     if (!await Bun.file(packageJsonPath).exists())
       return false;
     try {
-      const packageJson = await FileSys.readJson(packageJsonPath);
+      const packageJson = await FileSys2.readJson(packageJsonPath);
       return packageJson.name === dep && !!packageJson.version;
     } catch {
       return false;
@@ -106,27 +106,21 @@ class TypeScriptDependencyScanner2 {
     return this.#getImportSetsFromDependencies(depSets, fileDependencies);
   }
   #getImportSetsFromDependencies(depSets, fileDependencies) {
-    const importedDepSets = new Array(depSets.length);
-    for (let i = 0;i < depSets.length; i++)
-      importedDepSets[i] = new Set;
-    fileDependencies.forEach((imps) => {
-      imps.forEach((imp) => {
+    const importedDepSets = depSets.map(() => new Set);
+    for (const imps of fileDependencies.values())
+      for (const imp of imps) {
         if (imp.startsWith("."))
-          return;
-        const moduleName = imp;
-        const moduleNameParts = moduleName.split("/");
-        const subModuleLength = moduleNameParts.length;
-        for (let i = 0;i < subModuleLength; i++) {
-          const importName = moduleNameParts.slice(0, i + 1).join("/");
-          for (let j = 0;j < depSets.length; j++) {
-            if (depSets[j]?.has(importName)) {
-              importedDepSets[j]?.add(importName);
-              return;
-            }
-          }
+          continue;
+        const parts = imp.split("/");
+        for (let length = 1;length <= parts.length; length++) {
+          const importName = parts.slice(0, length).join("/");
+          const setIndex = depSets.findIndex((depSet) => depSet.has(importName));
+          if (setIndex === -1)
+            continue;
+          importedDepSets[setIndex]?.add(importName);
+          break;
         }
-      });
-    });
+      }
     return importedDepSets;
   }
   async getDependencies() {
@@ -134,43 +128,25 @@ class TypeScriptDependencyScanner2 {
     this.#fileRuntimeDependencies.clear();
     this.#fileTypeDependencies.clear();
     this.#visitedFiles.clear();
-    const files = await this.#findTypeScriptFiles(this.#directory);
-    for (const file of files)
+    for (const file of await this.#findFiles("**/*.{ts,tsx}"))
       await this.#analyzeFile(file, this.#directory);
     return this.#fileDependencies;
   }
-  async#findTypeScriptFiles(directory, {
+  async#findFiles(pattern, {
     excludeBuildFiles = false,
     excludeTestFiles = false
   } = {}) {
     const files = [];
-    const glob = new Bun.Glob("**/*.{ts,tsx}");
-    for await (const filePath of glob.scan({ cwd: directory, onlyFiles: true })) {
+    for await (const filePath of new Bun.Glob(pattern).scan({ cwd: this.#directory, onlyFiles: true })) {
       if (isSkippedPath(filePath))
         continue;
       if (excludeBuildFiles && filePath === "build.ts")
         continue;
       if (excludeTestFiles && testFileRegex.test(filePath))
         continue;
-      const fullPath = path.join(directory, filePath);
-      const relativePath = path.relative(this.#workspaceRoot, fullPath);
-      if (this.#ig.ignores(relativePath))
-        continue;
-      files.push(fullPath);
-    }
-    return files;
-  }
-  async#findCssFiles(directory) {
-    const files = [];
-    const glob = new Bun.Glob("**/*.css");
-    for await (const filePath of glob.scan({ cwd: directory, onlyFiles: true })) {
-      if (isSkippedPath(filePath))
-        continue;
-      const fullPath = path.join(directory, filePath);
-      const relativePath = path.relative(this.#workspaceRoot, fullPath);
-      if (this.#ig.ignores(relativePath))
-        continue;
-      files.push(fullPath);
+      const fullPath = path.join(this.#directory, filePath);
+      if (!this.#ig.ignores(path.relative(this.#workspaceRoot, fullPath)))
+        files.push(fullPath);
     }
     return files;
   }
@@ -179,7 +155,7 @@ class TypeScriptDependencyScanner2 {
       return;
     this.#visitedFiles.add(filePath);
     try {
-      const fileContent = await FileSys.readText(filePath);
+      const fileContent = await FileSys2.readText(filePath);
       const { imports, typeImports } = this.#extractImports(fileContent, filePath);
       const resolvedImports = await this.#resolveImports(imports, filePath, baseDir);
       const resolvedTypeImports = await this.#resolveImports(typeImports, filePath, baseDir);
@@ -191,19 +167,17 @@ class TypeScriptDependencyScanner2 {
   }
   async#resolveImports(imports, filePath, baseDir) {
     return await Promise.all(imports.map(async (importPath) => {
-      if (importPath.startsWith(".")) {
-        const resolvedPath = `./${path.join(path.relative(baseDir, filePath), importPath)}`;
-        return await this.#ensureExtension(resolvedPath);
-      }
-      return importPath;
+      if (!importPath.startsWith("."))
+        return importPath;
+      return await this.#ensureExtension(`./${path.join(path.relative(baseDir, filePath), importPath)}`);
     }));
   }
   async#ensureExtension(filePath) {
-    if (await FileSys.fileExists(`${filePath}.ts`))
+    if (await FileSys2.fileExists(`${filePath}.ts`))
       return `${filePath}.ts`;
-    else if (await FileSys.fileExists(`${filePath}.tsx`))
+    else if (await FileSys2.fileExists(`${filePath}.tsx`))
       return `${filePath}.tsx`;
-    else if (await FileSys.fileExists(filePath))
+    else if (await FileSys2.fileExists(filePath))
       return filePath;
     return `${filePath}.ts`;
   }
@@ -262,22 +236,14 @@ class TypeScriptDependencyScanner2 {
 `;
       const projectImports = imports.filter((i) => !i.startsWith("react") && !i.startsWith("@"));
       const externalImports = imports.filter((i) => i.startsWith("react") || i.startsWith("@"));
-      if (projectImports.length > 0) {
+      if (projectImports.length > 0)
         graph += `  Project dependencies:
-`;
-        projectImports.forEach((imp) => {
-          graph += `    \u2192 ${imp}
-`;
-        });
-      }
-      if (externalImports.length > 0) {
+${projectImports.map((imp) => `    \u2192 ${imp}
+`).join("")}`;
+      if (externalImports.length > 0)
         graph += `  External dependencies:
-`;
-        externalImports.forEach((imp) => {
-          graph += `    \u2192 ${imp}
-`;
-        });
-      }
+${externalImports.map((imp) => `    \u2192 ${imp}
+`).join("")}`;
       graph += `
 `;
     }

package/index-2wc41k5w.js

@@ -0,0 +1,49 @@
+// @bun
+import {
+  GlobalConfig,
+  CloudApi
+} from "./index-94s080qm.js";
+
+// pkgs/@akanjs/cli/tunnel/TunnelShare.ts
+import { TunnelAgent } from "akanjs/server/tunnel";
+
+class TunnelShare2 {
+  #api;
+  #agent;
+  grant;
+  #closed = false;
+  constructor(api, agent, grant) {
+    this.#api = api;
+    this.#agent = agent;
+    this.grant = grant;
+  }
+  static async open(app, { workspace, host, port, ttlMinutes, onLost }) {
+    const api = await CloudApi.fromHost(workspace, host ?? GlobalConfig.akanCloudHost);
+    const grant = await api.requestTunnel({ name: app.name, ...ttlMinutes ? { ttlMinutes } : {} });
+    const origin = `http://localhost:${port ?? await app.getDevPort()}`;
+    const agent = new TunnelAgent({
+      gatewayUrl: grant.gatewayUrl,
+      token: grant.token,
+      hostnames: [grant.hostname],
+      origin,
+      name: app.name,
+      ...onLost ? { onLost } : {}
+    });
+    await agent.start();
+    return new TunnelShare2(api, agent, grant);
+  }
+  get url() {
+    return this.grant.url;
+  }
+  async close() {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    await this.#agent.stop("cli exited");
+    try {
+      await this.#api.revokeTunnel(this.grant.code);
+    } catch {}
+  }
+}
+
+export { TunnelShare2 };

package/{index-j9yhg404.js → index-35mmm9ca.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   AppInfo
-} from "./index-2tv3fdx4.js";
+} from "./index-n3jk2501.js";
 
 // pkgs/@akanjs/devkit/slicePlanner.ts
 class SlicePlanner {
@@ -65,9 +65,6 @@ class SlicePlanner {
   constructor(app) {
     this.#app = app;
   }
-  async#trackedFiles(paths) {
-    return await this.#app.workspace.listGitFiles(paths);
-  }
   async#untrackedFiles(paths) {
     const [tracked, all] = await Promise.all([
       this.#app.workspace.listGitFiles(paths),
@@ -102,12 +99,12 @@ class SlicePlanner {
     const libs = appInfo.getLibs();
     const slicePaths = [`apps/${this.#app.name}`, ...libs.map((lib) => `libs/${lib}`)];
     const [appFiles, allTracked, untracked, rootPackageJson] = await Promise.all([
-      this.#trackedFiles([`apps/${this.#app.name}`]),
-      this.#trackedFiles(["."]),
+      this.#app.workspace.listGitFiles([`apps/${this.#app.name}`]),
+      this.#app.workspace.listGitFiles(["."]),
       this.#untrackedFiles(slicePaths),
       this.#app.workspace.getPackageJson()
     ]);
-    const libFiles = Object.fromEntries(await Promise.all(libs.map(async (lib) => [lib, await this.#trackedFiles([`libs/${lib}`])])));
+    const libFiles = Object.fromEntries(await Promise.all(libs.map(async (lib) => [lib, await this.#app.workspace.listGitFiles([`libs/${lib}`])])));
     const rootFiles = allTracked.filter((file) => !this.#isMemberFile(file));
     const required = SlicePlanner.#requiredDependencies(appInfo);
     const {