@akanjs/cli 3.0.0-alpha.70 → 3.0.0-alpha.72

package/{index-qt4nfr0n.js → index-eed7vc38.js}

@@ -1,43 +1,43 @@
 // @bun
 import {
   RepairRunner
-} from "./index-nj3w0r34.js";
+} from "./index-q13s3e01.js";
 import {
   WorkflowRunner
-} from "./index-fahkq20v.js";
+} from "./index-a341yqdh.js";
 import {
   ScalarScript
-} from "./index-v5fdxdre.js";
+} from "./index-9gqzgfsd.js";
 import {
   PrimitiveScript
-} from "./index-rb65xnw9.js";
+} from "./index-z52nhkjs.js";
 import {
   ModuleScript
-} from "./index-yg3hxk2k.js";
+} from "./index-vrra4ttx.js";
 import {
   isPlaceholderAppId
-} from "./index-hee7egtm.js";
+} from "./index-ym9g9ggs.js";
 import {
   AkanContextAnalyzer,
   akanMcpInstallConfigPaths,
   akanMcpInstallTargets,
+  buildResourceList,
   codexMcpConfigPath,
   createAkanCodexMcpServerBlock,
   createAkanMcpServer,
   renderDoctorText,
-  resourceList,
   upsertCodexMcpServerBlock
-} from "./index-va15r8h5.js";
+} from "./index-bmz9crym.js";
 import {
   buildAkanModuleContextIndex,
   createWorkflowBaselineSummary,
   createWorkflowStepRegistry,
   jsonText,
   toolingRolloutGate
-} from "./index-ytaqtc04.js";
+} from "./index-q0s2dp3y.js";
 import {
   Prompter
-} from "./index-j37qq1f2.js";
+} from "./index-k7731a4v.js";
 import {
   getMobileTargets
 } from "./index-76rn3g2c.js";
@@ -45,10 +45,10 @@ import {
   CommandContainer,
   runner,
   script
-} from "./index-e31ghfp5.js";
+} from "./index-akz5xvyw.js";
 import {
   AppExecutor
-} from "./index-nkwmnqwn.js";
+} from "./index-h9cybjep.js";
 
 // pkgs/@akanjs/cli/context/context.script.ts
 import { Logger } from "akanjs/common";
@@ -380,12 +380,15 @@ var applyMcpTools = [
     }
   }
 ];
-var listAkanMcpTools = (mode = "readonly") => {
-  if (mode === "readonly")
-    return readonlyMcpTools;
-  if (mode === "plan")
-    return [...readonlyMcpTools, ...planMcpTools];
-  return [...readonlyMcpTools, ...planMcpTools, ...applyMcpTools];
+var listAkanMcpTools = (mode = "readonly", { guidelineNames = [] } = {}) => {
+  const tools = mode === "readonly" ? readonlyMcpTools : mode === "plan" ? [...readonlyMcpTools, ...planMcpTools] : [...readonlyMcpTools, ...planMcpTools, ...applyMcpTools];
+  if (guidelineNames.length === 0)
+    return tools;
+  return tools.map((tool) => tool.name === "get_guideline" ? {
+    ...tool,
+    description: `${tool.description ?? ""} One of: ${guidelineNames.join(", ")}.`.trim(),
+    inputSchema: { ...tool.inputSchema, properties: { name: { type: "string", enum: [...guidelineNames] } } }
+  } : tool);
 };
 var createAkanValidationContract = (listTools = listAkanMcpTools) => ({
   schemaVersion: 1,
@@ -604,6 +607,10 @@ var createCliWorkflowStepRegistry = (workspace) => createWorkflowStepRegistry({
 });
 
 // pkgs/@akanjs/cli/context/context.runner.ts
+var toolErrorText = (error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.replace(/\/(?:[^\s"'/]+\/)*(?=(?:pkgs|apps|libs|infra)\/)/g, "<workspace>/");
+};
 var workflowDiagnosticFromContext = (diagnostic) => ({
   severity: diagnostic.severity,
   code: diagnostic.code,
@@ -720,8 +727,8 @@ class ContextRunner extends runner("context") {
     await workspace.writeFile(codexMcpConfigPath, merged);
     return codexMcpConfigPath;
   }
-  listMcpTools(mode = "readonly") {
-    return listAkanMcpTools(mode);
+  listMcpTools(mode = "readonly", { guidelineNames = [] } = {}) {
+    return listAkanMcpTools(mode, { guidelineNames });
   }
   async callMcpTool(workspace, name, args = {}, { mode = "readonly" } = {}) {
     const availableTools = this.listMcpTools(mode);
@@ -851,17 +858,20 @@ class ContextRunner extends runner("context") {
 ${payload}`);
     };
     const respond = (id, result, framing) => {
-      writeMessage({ jsonrpc: "2.0", id, result }, framing);
+      writeMessage({ jsonrpc: "2.0", id: id ?? null, result }, framing);
     };
     const respondError = (id, code, message, framing) => {
-      writeMessage({ jsonrpc: "2.0", id, error: { code, message } }, framing);
+      writeMessage({ jsonrpc: "2.0", id: id ?? null, error: { code, message } }, framing);
     };
+    const guidelineNames = await Prompter.listGuidelines();
+    const resources = buildResourceList(guidelineNames);
     const readResource = async (uri) => {
-      const context = await AkanContextAnalyzer.analyze(workspace);
-      if (uri === "akan://docs/framework" || uri === "akan://guidelines/framework")
+      if (uri === "akan://docs/framework")
         return { uri, mimeType: "text/markdown", text: await Prompter.getInstruction("framework") };
-      if (uri === "akan://guidelines/modelSignal")
-        return { uri, mimeType: "text/markdown", text: await Prompter.getInstruction("modelSignal") };
+      const guideline = /^akan:\/\/guidelines\/(.+)$/.exec(uri)?.[1];
+      if (guideline)
+        return { uri, mimeType: "text/markdown", text: await Prompter.getInstruction(guideline) };
+      const context = await AkanContextAnalyzer.analyze(workspace);
       if (uri === "akan://workspace/summary")
         return { uri, mimeType: "application/json", text: jsonText(context, { trailingNewline: false }) };
       if (uri === "akan://workspace/apps")
@@ -883,7 +893,7 @@ ${payload}`);
       }
       throw new Error(`Unknown resource: ${uri}`);
     };
-    const handle = async (request, framing) => {
+    const handleRequest = async (request, framing) => {
       const params = request.params ?? {};
       if (request.method === "initialize") {
         respond(request.id, {
@@ -893,7 +903,7 @@ ${payload}`);
         }, framing);
       } else if (request.method === "tools/list") {
         respond(request.id, {
-          tools: this.listMcpTools(mode)
+          tools: this.listMcpTools(mode, { guidelineNames })
         }, framing);
       } else if (request.method === "tools/call") {
         const name = params.name;
@@ -909,16 +919,39 @@ ${payload}`);
             ]
           }, framing);
         } catch (error) {
-          respondError(request.id, -32602, error instanceof Error ? error.message : String(error), framing);
+          respond(request.id, { content: [{ type: "text", text: toolErrorText(error) }], isError: true }, framing);
         }
       } else if (request.method === "resources/list") {
-        respond(request.id, { resources: resourceList }, framing);
+        respond(request.id, { resources }, framing);
       } else if (request.method === "resources/read") {
         respond(request.id, { contents: [await readResource(params.uri)] }, framing);
-      } else if (!request.method.endsWith("/initialized")) {
+      } else {
         respondError(request.id, -32601, `Unknown method: ${request.method}`, framing);
       }
     };
+    const handle = async (request, framing) => {
+      if (request.id === undefined || request.id === null)
+        return;
+      try {
+        await handleRequest(request, framing);
+      } catch (error) {
+        respondError(request.id, -32603, error instanceof Error ? error.message : String(error), framing);
+      }
+    };
+    const handleFrame = async (payload, framing) => {
+      let request;
+      try {
+        request = JSON.parse(payload);
+      } catch (error) {
+        respondError(null, -32700, error instanceof Error ? error.message : String(error), framing);
+        return;
+      }
+      if (!request || typeof request !== "object" || typeof request.method !== "string") {
+        respondError(null, -32600, "Invalid Request: expected a JSON-RPC 2.0 object with a method", framing);
+        return;
+      }
+      await handle(request, framing);
+    };
     const parseContentLengthMessage = async () => {
       const headerEnd = buffer.indexOf(`\r
 \r
@@ -938,7 +971,7 @@ ${payload}`);
         return false;
       const body = buffer.slice(bodyStart, bodyEnd);
       buffer = buffer.slice(bodyEnd);
-      await handle(JSON.parse(body), "content-length");
+      await handleFrame(body, "content-length");
       return true;
     };
     const parseLineMessage = async () => {
@@ -950,7 +983,7 @@ ${payload}`);
       buffer = buffer.slice(lineEnd + 1);
       if (!line)
         return true;
-      await handle(JSON.parse(line), "newline");
+      await handleFrame(line, "newline");
       return true;
     };
     const parse = async () => {

package/{index-46tjzh6s.js → index-h5sr2nnj.js}

@@ -9,6 +9,8 @@ import * as path from "path";
 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 builtinModuleSet = new Set([...builtinModules, ...builtinModules.map((mod) => `node:${mod}`)]);
 var stripShebang = (source) => source.replace(/^#!.*(?:\r?\n|$)/, "");
 
@@ -19,22 +21,22 @@ class TypeScriptDependencyScanner {
   #visitedFiles = new Set;
   #tsTranspiler = new Bun.Transpiler({ loader: "ts" });
   #tsxTranspiler = new Bun.Transpiler({ loader: "tsx" });
-  directory;
-  rootPackageJson;
-  ig;
-  workspaceRoot;
+  #directory;
+  #rootPackageJson;
+  #ig;
+  #workspaceRoot;
   constructor(directory, {
     workspaceRoot,
     rootPackageJson,
     gitignorePatterns = []
   }) {
-    this.directory = directory;
-    this.rootPackageJson = rootPackageJson;
-    this.ig = ignore().add(gitignorePatterns);
-    this.workspaceRoot = workspaceRoot;
+    this.#directory = directory;
+    this.#rootPackageJson = rootPackageJson;
+    this.#ig = ignore().add(gitignorePatterns);
+    this.#workspaceRoot = workspaceRoot;
   }
   async getMonorepoDependencies(projectName, { pkgs = [], libs = [] } = {}) {
-    const npmSet = new Set(Object.keys({ ...this.rootPackageJson.dependencies, ...this.rootPackageJson.devDependencies }));
+    const npmSet = new Set(Object.keys({ ...this.#rootPackageJson.dependencies, ...this.#rootPackageJson.devDependencies }));
     const pkgPathSet = new Set(pkgs);
     const libPathSet = new Set(libs.map((lib) => `@libs/${lib}`));
     await this.getDependencies();
@@ -52,11 +54,11 @@ class TypeScriptDependencyScanner {
   async getPackageBuildDependencies(projectName) {
     const runtimeDeps = new Set;
     const devDeps = new Set;
-    const sourceFiles = await this.#findTypeScriptFiles(this.directory, {
+    const sourceFiles = await this.#findTypeScriptFiles(this.#directory, {
       excludeBuildFiles: true,
       excludeTestFiles: true
     });
-    const cssFiles = await this.#findCssFiles(this.directory);
+    const cssFiles = await this.#findCssFiles(this.#directory);
     for (const filePath of sourceFiles) {
       const fileContent = await FileSys.readText(filePath);
       const { imports, typeImports } = this.#extractImports(fileContent, filePath);
@@ -67,7 +69,7 @@ class TypeScriptDependencyScanner {
       const fileContent = await FileSys.readText(filePath);
       this.#addNormalizedImports(runtimeDeps, this.#extractCssPluginImports(fileContent), projectName);
     }
-    const buildFilePath = path.join(this.directory, "build.ts");
+    const buildFilePath = path.join(this.#directory, "build.ts");
     if (await FileSys.fileExists(buildFilePath)) {
       const fileContent = await FileSys.readText(buildFilePath);
       const { imports, typeImports } = this.#extractImports(fileContent, buildFilePath);
@@ -75,7 +77,7 @@ class TypeScriptDependencyScanner {
     }
     for (const dep of runtimeDeps)
       devDeps.delete(dep);
-    const rootDeps = { ...this.rootPackageJson.dependencies, ...this.rootPackageJson.devDependencies };
+    const rootDeps = { ...this.#rootPackageJson.dependencies, ...this.#rootPackageJson.devDependencies };
     const missingDeps = [];
     for (const dep of [...runtimeDeps, ...devDeps]) {
       if (rootDeps[dep] || await this.#hasWorkspacePackage(dep))
@@ -89,7 +91,7 @@ class TypeScriptDependencyScanner {
     };
   }
   async#hasWorkspacePackage(dep) {
-    const packageJsonPath = path.join(this.workspaceRoot, "pkgs", dep, "package.json");
+    const packageJsonPath = path.join(this.#workspaceRoot, "pkgs", dep, "package.json");
     if (!await Bun.file(packageJsonPath).exists())
       return false;
     try {
@@ -132,9 +134,9 @@ class TypeScriptDependencyScanner {
     this.#fileRuntimeDependencies.clear();
     this.#fileTypeDependencies.clear();
     this.#visitedFiles.clear();
-    const files = await this.#findTypeScriptFiles(this.directory);
+    const files = await this.#findTypeScriptFiles(this.#directory);
     for (const file of files)
-      await this.#analyzeFile(file, this.directory);
+      await this.#analyzeFile(file, this.#directory);
     return this.#fileDependencies;
   }
   async#findTypeScriptFiles(directory, {
@@ -142,18 +144,17 @@ class TypeScriptDependencyScanner {
     excludeTestFiles = false
   } = {}) {
     const files = [];
-    const skipDirs = ["node_modules", "dist", "build", ".git", ".next", "public", "ios", "android"];
     const glob = new Bun.Glob("**/*.{ts,tsx}");
     for await (const filePath of glob.scan({ cwd: directory, onlyFiles: true })) {
-      if (skipDirs.some((dir) => filePath.includes(`/${dir}/`) || filePath.startsWith(`${dir}/`)))
+      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))
+      const relativePath = path.relative(this.#workspaceRoot, fullPath);
+      if (this.#ig.ignores(relativePath))
         continue;
       files.push(fullPath);
     }
@@ -161,14 +162,13 @@ class TypeScriptDependencyScanner {
   }
   async#findCssFiles(directory) {
     const files = [];
-    const skipDirs = ["node_modules", "dist", "build", ".git", ".next", "public", "ios", "android"];
     const glob = new Bun.Glob("**/*.css");
     for await (const filePath of glob.scan({ cwd: directory, onlyFiles: true })) {
-      if (skipDirs.some((dir) => filePath.includes(`/${dir}/`) || filePath.startsWith(`${dir}/`)))
+      if (isSkippedPath(filePath))
         continue;
       const fullPath = path.join(directory, filePath);
-      const relativePath = path.relative(this.workspaceRoot, fullPath);
-      if (this.ig.ignores(relativePath))
+      const relativePath = path.relative(this.#workspaceRoot, fullPath);
+      if (this.#ig.ignores(relativePath))
         continue;
       files.push(fullPath);
     }

package/{index-nkwmnqwn.js → index-h9cybjep.js}

@@ -551,6 +551,7 @@ ${this.basePaths.size ? `ENV AKAN_PUBLIC_BASE_PATHS=${[...this.basePaths].join("
 ENV AKAN_PUBLIC_DEFAULT_LOCALE=${this.i18n.defaultLocale}
 ENV AKAN_PUBLIC_LOCALES=${this.i18n.locales.join(",")}
 ENV AKAN_PUBLIC_OPERATION_MODE=cloud
+ENV AKAN_LOG_TO_FILE=0
 ${webEnvLines}
 CMD [${command.map((c) => `"${c}"`).join(",")}]`;
   }
@@ -719,6 +720,53 @@ import { spawn } from "child_process";
 import { existsSync, readFileSync } from "fs";
 import path2 from "path";
 import chalk from "chalk";
+var parseBiomeReport = (output) => {
+  for (let start = output.indexOf("{");start !== -1; start = output.indexOf("{", start + 1)) {
+    const end = objectEndAt(output, start);
+    if (end === -1)
+      break;
+    const report = asBiomeReport(output.slice(start, end + 1));
+    if (report)
+      return report;
+  }
+  throw new Error(output.trim() || "No Biome JSON output");
+};
+var objectEndAt = (output, start) => {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let idx = start;idx < output.length; idx += 1) {
+    const char = output[idx];
+    if (inString) {
+      if (escaped)
+        escaped = false;
+      else if (char === "\\")
+        escaped = true;
+      else if (char === '"')
+        inString = false;
+      continue;
+    }
+    if (char === '"')
+      inString = true;
+    else if (char === "{")
+      depth += 1;
+    else if (char === "}" && --depth === 0)
+      return idx;
+  }
+  return -1;
+};
+var asBiomeReport = (candidate) => {
+  try {
+    const parsed = JSON.parse(candidate);
+    if (!parsed || typeof parsed !== "object")
+      return null;
+    if (!("diagnostics" in parsed) && !("summary" in parsed))
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+};
 var BIOME_CONFIG_FILES = ["biome.json", "biome.jsonc"];
 
 class Linter {
@@ -775,13 +823,6 @@ class Linter {
       proc.stdin.end(input);
     });
   }
-  #parseBiomeReport(output) {
-    const jsonStart = output.indexOf("{");
-    const jsonEnd = output.lastIndexOf("}");
-    if (jsonStart === -1 || jsonEnd === -1 || jsonEnd < jsonStart)
-      throw new Error(output.trim() || "No Biome JSON output");
-    return JSON.parse(output.slice(jsonStart, jsonEnd + 1));
-  }
   #diagnosticFilePath(diagnostic, fallbackFilePath) {
     const diagnosticPath = diagnostic.location?.path;
     if (!diagnosticPath)
@@ -854,7 +895,7 @@ class Linter {
       this.configPath,
       this.#toBiomePath(filePath)
     ]);
-    const report = this.#parseBiomeReport(stdout || stderr);
+    const report = parseBiomeReport(stdout || stderr);
     const results = this.#toLintResults(report, filePath);
     const { errors, warnings } = this.#splitMessages(results);
     const output = write && existsSync(filePath) ? readFileSync(filePath, "utf8") : undefined;
@@ -976,6 +1017,25 @@ ${errorText}, ${warningText} found`];
     const lintResult = await this.lintFile(resolvedFilePath);
     return { ...lintResult, fixed: stdout !== source, output: stdout };
   }
+  async fixFiles(filePaths) {
+    const resolved = filePaths.map((filePath) => this.#resolveFilePath(filePath)).filter(existsSync);
+    if (resolved.length === 0)
+      return { fixed: [] };
+    const before = new Map(resolved.map((filePath) => [filePath, readFileSync(filePath, "utf8")]));
+    await this.#runBiome([
+      "check",
+      "--write",
+      "--reporter=json",
+      "--max-diagnostics=none",
+      "--no-errors-on-unmatched",
+      "--config-path",
+      this.configPath,
+      ...resolved.map((filePath) => this.#toBiomePath(filePath))
+    ]);
+    return {
+      fixed: resolved.filter((filePath) => readFileSync(filePath, "utf8") !== before.get(filePath))
+    };
+  }
   async getConfigForFile(filePath) {
     const resolvedFilePath = this.#resolveFilePath(filePath);
     if (!existsSync(resolvedFilePath))
@@ -1126,7 +1186,7 @@ var moduleUiFileTypes = {
   scalar: new Set(["Template", "Unit"])
 };
 var testFilePattern = /\.(test|spec)\.(ts|tsx)$/;
-var createDependencyScanner = async (exec) => (await import("./dependencyScanner-rbs2407b.js")).TypeScriptDependencyScanner.from(exec);
+var createDependencyScanner = async (exec) => (await import("./dependencyScanner-aqg3dkks.js")).TypeScriptDependencyScanner.from(exec);
 var isAllowedTestFile = (filename) => testFilePattern.test(filename);
 var getScanPath = (exec, relativePath) => path4.posix.join(`${exec.type}s`, exec.name, relativePath.split(path4.sep).join("/"));
 async function clearGeneratedRootCapacitorConfigs(exec) {
@@ -1543,7 +1603,7 @@ class LibInfo extends ScanInfo {
 class PkgInfo {
   exec;
   name;
-  scanResult;
+  #scanResult;
   static async scanExecutor(exec) {
     const [tsconfig, rootPackageJson] = await Promise.all([exec.getTsConfig(), exec.workspace.getPackageJson()]);
     const scanner = await createDependencyScanner(exec);
@@ -1574,10 +1634,10 @@ class PkgInfo {
   constructor(exec, scanResult) {
     this.exec = exec;
     this.name = exec.name;
-    this.scanResult = scanResult;
+    this.#scanResult = scanResult;
   }
   getScanResult() {
-    return this.scanResult;
+    return this.#scanResult;
   }
 }
 
@@ -2167,10 +2227,24 @@ class Executor {
       ...options.dict ?? {},
       ...Object.fromEntries(Object.entries(options.dict ?? {}).map(([key, value]) => [capitalize(key), capitalize(value)]))
     };
-    return this._applyTemplate({ ...options, dict });
+    const fileContents = await this._applyTemplate({ ...options, dict });
+    await this.#formatAppliedTemplate(fileContents);
+    return fileContents;
+  }
+  async#formatAppliedTemplate(fileContents) {
+    const filePaths = fileContents.map((fileContent) => fileContent.filePath).filter((filePath) => filePath.endsWith(".ts") || filePath.endsWith(".tsx"));
+    if (filePaths.length === 0)
+      return;
+    try {
+      const { fixed } = await this.getLinter().fixFiles(filePaths);
+      if (fixed.length > 0)
+        this.logger.verbose(`Formatted ${fixed.length} scaffolded file(s)`);
+    } catch (err) {
+      this.logger.verbose(`Skipped formatting scaffolded files: ${err instanceof Error ? err.message : String(err)}`);
+    }
   }
   async getTypeChecker() {
-    const { TypeChecker } = await import("./typeChecker-g6bh0xfv.js");
+    const { TypeChecker } = await import("./typeChecker-yhs4eht8.js");
     this.typeChecker ??= new TypeChecker(this);
     return this.typeChecker;
   }
@@ -2356,10 +2430,10 @@ class WorkspaceExecutor extends Executor {
   }
   async commit(message, { init = false, add = true } = {}) {
     if (init)
-      await this.exec(`git init --quiet`);
+      await this.spawn("git", ["init", "--quiet"]);
     if (add)
-      await this.exec(`git add .`);
-    await this.exec(`git commit --quiet -m "${message}"`);
+      await this.spawn("git", ["add", "."]);
+    await this.spawn("git", ["commit", "--quiet", "-m", message]);
   }
   async#getDirHasFile(basePath, targetFilename) {
     const AVOID_DIRS = ["node_modules", "dist", "public", "webkit"];
@@ -2698,8 +2772,7 @@ class AppExecutor extends SysExecutor {
     if (type === "build") {
       this.#excludeDevOnlyPages = true;
       this.#pageKeys = null;
-      if (await this.exists(this.dist.cwdPath))
-        await this.dist.exec(`rm -rf ${this.dist.cwdPath}`);
+      await this.dist.removeDir(this.dist.cwdPath);
       await Promise.all([this.dist.mkdir("private"), this.dist.mkdir("public")]);
       await Promise.all([
         this.cp("private", `${this.dist.cwdPath}/private`, { dereference: true }),

package/{index-p681w089.js → index-hvbdre8z.js}

@@ -2,10 +2,10 @@
 import {
   runner,
   script
-} from "./index-e31ghfp5.js";
+} from "./index-akz5xvyw.js";
 import {
   LibExecutor
-} from "./index-nkwmnqwn.js";
+} from "./index-h9cybjep.js";
 
 // pkgs/@akanjs/cli/semver.ts
 var stripRangeOperator = (version) => version.replace(/^[\s^~>=<v]+/, "").trim();
@@ -34,13 +34,13 @@ var compareSemver = (a, b) => {
 // pkgs/@akanjs/cli/library/library.runner.ts
 class LibraryRunner extends runner("library") {
   async createLibrary(libName, workspace) {
-    await workspace.exec(`mkdir -p libs/${libName}`);
+    await workspace.mkdir(`libs/${libName}`);
     await workspace.applyTemplate({ basePath: `libs/${libName}`, template: "libRoot", dict: { libName } });
     const lib = LibExecutor.from(workspace, libName);
     return lib;
   }
   async removeLibrary(lib) {
-    await lib.workspace.exec(`rm -rf libs/${lib.name}`);
+    await lib.workspace.removeDir(`libs/${lib.name}`);
   }
   async#copyInstalledLibrary(workspace, libName) {
     const installedPackageJson = `node_modules/akanjs/libs/${libName}/package.json`;
@@ -88,7 +88,6 @@ class LibraryRunner extends runner("library") {
     await lib.workspace.spawn("bun", ["install"]);
     await lib.workspace.commit(`Merge ${lib.name} library dependencies`);
   }
-  async testLibrary(lib) {}
 }
 
 // pkgs/@akanjs/cli/library/library.script.ts
@@ -118,11 +117,6 @@ class LibraryScript extends script("library", [LibraryRunner]) {
     await this.libraryRunner.mergeLibraryDependencies(lib);
     mergeSpinner.succeed(`${libName} library (libs/${libName}) dependencies merged to root package.json`);
   }
-  async testLibrary(lib) {
-    const spinner = lib.spinning("Testing library...");
-    await this.libraryRunner.testLibrary(lib);
-    spinner.succeed(`Library ${lib.name} (libs/${lib.name}) test is successful`);
-  }
 }
 
 export { LibraryScript };

package/{index-qnv0aqmm.js → index-jcm6zr20.js}

@@ -349,7 +349,7 @@ var resolveNodePackageExport = async (workspaceRoot, specifier) => {
     const subpath = specifier === packageName ? "." : `.${specifier.slice(packageName.length)}`;
     const exported = resolvePackageExport(pkgJson.exports, subpath);
     const rel = exported ?? (subpath === "." ? pkgJson.module ?? pkgJson.main ?? "index.js" : null);
-    if (!rel || !rel.startsWith("."))
+    if (!rel?.startsWith("."))
       return null;
     const entryFile = await resolveFileCandidate(path2.resolve(pkgDir, rel));
     if (!entryFile)
@@ -1518,6 +1518,8 @@ class AutoImportSync {
     const [scope, project, facet] = parts;
     if (scope !== "apps" && scope !== "libs" || !project || !facet)
       return null;
+    if (facet === "lib" && parts[3] === "__lib")
+      return null;
     const role = roleFor(facet, base);
     if (!role)
       return null;

package/{index-j37qq1f2.js → index-k7731a4v.js}

@@ -19,7 +19,6 @@ class Prompter {
     return candidates[0];
   }
   static async selectGuideline() {
-    const guidelineRoot = await Prompter.#getGuidelineRoot();
     const guideNames = await Prompter.listGuidelines();
     return await select({
       message: "Select a guideline",
@@ -37,10 +36,11 @@ class Prompter {
     return JSON.parse(guideJson);
   }
   static async getInstruction(guideName) {
+    const guideNames = await Prompter.listGuidelines();
+    if (!guideNames.includes(guideName))
+      throw new Error(`Unknown guideline "${guideName}". Available: ${guideNames.join(", ")}`);
     const guidelineRoot = await Prompter.#getGuidelineRoot();
-    const filePath = `${guidelineRoot}/${guideName}/${guideName}.instruction.md`;
-    const content = await fsPromise.readFile(filePath, "utf-8");
-    return content;
+    return await fsPromise.readFile(`${guidelineRoot}/${guideName}/${guideName}.instruction.md`, "utf-8");
   }
   static async getUpdateRequest(guideName) {
     return await input({

package/{index-ytaqtc04.js → index-q0s2dp3y.js}

@@ -2,7 +2,7 @@
 import {
   AppExecutor,
   LibExecutor
-} from "./index-nkwmnqwn.js";
+} from "./index-h9cybjep.js";
 
 // pkgs/@akanjs/devkit/workflow/utils.ts
 var jsonText = (value, { trailingNewline = true } = {}) => `${JSON.stringify(value, null, 2)}${trailingNewline ? `

package/{index-nj3w0r34.js → index-q13s3e01.js}

@@ -1,17 +1,17 @@
 // @bun
 import {
   AkanContextAnalyzer
-} from "./index-va15r8h5.js";
+} from "./index-bmz9crym.js";
 import {
   createRepairReport,
   generatedFilePathsForTarget,
   renderRepairReport,
   writeGeneratedSyncState,
   writeWorkflowRunArtifact
-} from "./index-ytaqtc04.js";
+} from "./index-q0s2dp3y.js";
 import {
   runner
-} from "./index-e31ghfp5.js";
+} from "./index-akz5xvyw.js";
 
 // pkgs/@akanjs/cli/repair/repair.runner.ts
 var commandForShell = (command) => command.startsWith("akan ") ? `bun run ${command}` : command;