@akanjs/cli 3.0.0-alpha.1 → 3.0.0-alpha.100

package/index-5svjba73.js

@@ -0,0 +1,159 @@
+// @bun
+import {
+  AppInfo
+} from "./index-qsq3q8fy.js";
+
+// pkgs/@akanjs/devkit/slicePlanner.ts
+class SlicePlanner {
+  static memberDirs = ["apps", "libs", "pkgs"];
+  static toolchainDependencies = [
+    "@akanjs/cli",
+    "@akanjs/devkit",
+    "@biomejs/biome",
+    "@types/bun",
+    "akanjs",
+    "tailwindcss",
+    "typescript"
+  ];
+  static akanPackages = ["akanjs", "@akanjs/devkit", "@akanjs/cli"];
+  static async#frameworkPeers(workspace) {
+    const peers = new Set;
+    let found = false;
+    for (const akanPackage of SlicePlanner.akanPackages) {
+      for (const prefix of ["node_modules", "pkgs"]) {
+        const manifestPath = `${prefix}/${akanPackage}/package.json`;
+        if (!await workspace.exists(manifestPath))
+          continue;
+        const manifest = await workspace.readJson(manifestPath);
+        for (const peer of Object.keys(manifest.peerDependencies ?? {}))
+          peers.add(peer);
+        found = true;
+        break;
+      }
+    }
+    return found ? peers : null;
+  }
+  static typesPackageOf(dependency) {
+    return dependency.startsWith("@") ? `@types/${dependency.slice(1).replace("/", "__")}` : `@types/${dependency}`;
+  }
+  static async pruneDependencies(workspace, rootPackageJson, required) {
+    const peers = await SlicePlanner.#frameworkPeers(workspace);
+    const { workspaces: _workspaces, ...rest } = rootPackageJson;
+    if (!peers)
+      return {
+        packageJson: rest,
+        pruned: [],
+        warnings: [`dependencies carried whole \u2014 none of ${SlicePlanner.akanPackages.join(", ")} is installed`]
+      };
+    const keep = new Set([...SlicePlanner.toolchainDependencies, ...peers, ...required]);
+    for (const dependency of [...keep])
+      keep.add(SlicePlanner.typesPackageOf(dependency));
+    const pick = (entries) => Object.fromEntries(Object.entries(entries ?? {}).filter(([name]) => keep.has(name)));
+    const patched = rootPackageJson.patchedDependencies ?? {};
+    const packageJson = {
+      ...rest,
+      dependencies: pick(rootPackageJson.dependencies),
+      devDependencies: pick(rootPackageJson.devDependencies),
+      ...Object.keys(patched).length ? {
+        patchedDependencies: Object.fromEntries(Object.entries(patched).filter(([spec]) => keep.has(spec.slice(0, spec.lastIndexOf("@")))))
+      } : {}
+    };
+    const pruned = Object.keys({ ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies }).filter((name) => !keep.has(name)).sort();
+    return { packageJson, pruned, warnings: [] };
+  }
+  #app;
+  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),
+      this.#app.workspace.listGitFiles(paths, { untracked: true })
+    ]);
+    const trackedSet = new Set(tracked);
+    return all.filter((file) => !trackedSet.has(file));
+  }
+  #isMemberFile(file) {
+    return SlicePlanner.memberDirs.includes(file.split("/")[0] ?? "");
+  }
+  static #requiredDependencies(appInfo) {
+    const scanResults = [
+      appInfo.getScanResult(),
+      ...[...appInfo.getLibInfos().values()].map((lib) => lib.getScanResult())
+    ];
+    return new Set([
+      ...scanResults.flatMap((scanResult) => [
+        ...scanResult.dependencies,
+        ...scanResult.devDependencies,
+        ...scanResult.pkgDeps
+      ])
+    ]);
+  }
+  async#patchWarnings(packageJson) {
+    const patchedDependencies = packageJson.patchedDependencies ?? {};
+    const missing = (await Promise.all(Object.entries(patchedDependencies).map(async ([spec, patchPath]) => await this.#app.workspace.exists(patchPath) ? null : `${spec} -> ${patchPath}`))).filter((entry) => !!entry);
+    return missing.length ? [`patchedDependencies references a missing patch file: ${missing.join(", ")}`] : [];
+  }
+  async plan() {
+    const appInfo = await AppInfo.fromExecutor(this.#app);
+    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.#untrackedFiles(slicePaths),
+      this.#app.workspace.getPackageJson()
+    ]);
+    const libFiles = Object.fromEntries(await Promise.all(libs.map(async (lib) => [lib, await this.#trackedFiles([`libs/${lib}`])])));
+    const rootFiles = allTracked.filter((file) => !this.#isMemberFile(file));
+    const required = SlicePlanner.#requiredDependencies(appInfo);
+    const {
+      packageJson,
+      pruned,
+      warnings: manifestWarnings
+    } = await SlicePlanner.pruneDependencies(this.#app.workspace, rootPackageJson, required);
+    const warnings = [
+      ...untracked.length ? [`${untracked.length} untracked file(s) under the slice paths: ${untracked.join(", ")}`] : [],
+      ...rootPackageJson.workspaces ? ["root `workspaces` dropped \u2014 a slice consumes akanjs from the registry"] : [],
+      ...manifestWarnings,
+      ...await this.#patchWarnings(rootPackageJson)
+    ];
+    return {
+      app: this.#app.name,
+      libs,
+      appFiles,
+      libFiles,
+      rootFiles,
+      packageJson,
+      requiredDependencies: [...required].sort(),
+      unusedDependencies: pruned,
+      warnings
+    };
+  }
+}
+var rootEntriesOf = (rootFiles) => [...new Set(rootFiles.map((file) => file.split("/")[0] ?? file))].sort();
+function formatSlicePlan(plan) {
+  const libCounts = Object.entries(plan.libFiles).map(([lib, files]) => `  - libs/${lib}: ${files.length} files`);
+  const sections = [
+    "Akan Slice Plan",
+    `app: ${plan.app} (apps/${plan.app}: ${plan.appFiles.length} files)`,
+    `libs: ${plan.libs.length ? plan.libs.join(", ") : "(none)"}`,
+    ...libCounts,
+    `workspace shell: ${plan.rootFiles.length} files across ${rootEntriesOf(plan.rootFiles).join(", ")}`,
+    "",
+    `Root dependencies this slice does not use (${plan.unusedDependencies.length}) \u2014 pruned:`,
+    "",
+    ...plan.unusedDependencies.length ? plan.unusedDependencies.map((dep) => `  - ${dep}`) : ["  (none)"],
+    "",
+    `Warnings (${plan.warnings.length}):`,
+    "",
+    ...plan.warnings.length ? plan.warnings.map((warning) => `  - ${warning}`) : ["  (none)"]
+  ];
+  return sections.join(`
+`);
+}
+
+export { SlicePlanner, formatSlicePlan };

package/index-6wwzs1bc.js

@@ -0,0 +1,7 @@
+// @bun
+// pkgs/@akanjs/devkit/getDirname.ts
+import path from "path";
+import { fileURLToPath } from "url";
+var getDirname2 = (url) => path.dirname(fileURLToPath(url));
+
+export { getDirname2 };

package/{index-k95xkh4p.js → index-7d6vny25.js}

@@ -2,16 +2,16 @@
 import {
   runner,
   script
-} from "./index-8hsbnyes.js";
+} from "./index-znynzt5w.js";
 import {
-  PkgExecutor
-} from "./index-hgna5rjy.js";
+  FileSys
+} from "./index-q0y2jq9j.js";
 import {
-  TypeScriptDependencyScanner
-} from "./index-46tjzh6s.js";
+  PkgExecutor
+} from "./index-qsq3q8fy.js";
 import {
-  FileSys
-} from "./index-67546d0j.js";
+  TypeScriptDependencyScanner2
+} from "./index-kcxmv48c.js";
 
 // pkgs/@akanjs/cli/package/package.runner.ts
 import path2 from "path";
@@ -140,7 +140,7 @@ class PackageRunner extends runner("package") {
     await workspace.setPkgTsPaths(pkgName);
   }
   async removePackage(pkg) {
-    await pkg.workspace.exec(`rm -rf pkgs/${pkg.name}`);
+    await pkg.workspace.removeDir(`pkgs/${pkg.name}`);
     await pkg.workspace.unsetPkgTsPaths(pkg.name);
   }
   async scanSync(pkg) {
@@ -150,7 +150,7 @@ class PackageRunner extends runner("package") {
   async buildPackage(pkg) {
     await $`rm -rf ${pkg.dist.cwdPath}`;
     await pkg.dist.mkdir(pkg.dist.cwdPath);
-    const scanner = await TypeScriptDependencyScanner.from(pkg);
+    const scanner = await TypeScriptDependencyScanner2.from(pkg);
     const { npmDeps, npmDevDeps, missingDeps } = await scanner.getPackageBuildDependencies(pkg.name);
     const packageRuntimeDependencies = {
       "@akanjs/devkit": ["tailwind-scrollbar"]
@@ -163,13 +163,17 @@ class PackageRunner extends runner("package") {
         "tailwind-scrollbar"
       ].filter((dep) => dep !== "akanjs" && dep !== "@akanjs/devkit");
     }
-    const bundledRuntimeDeps = new Set(pkg.name === "@akanjs/cli" ? ["@akanjs/devkit"] : []);
+    const packageBundledRuntimeDependencies = {
+      "@akanjs/cli": ["@akanjs/devkit"],
+      akanjs: ["use-agentic"]
+    };
+    const bundledRuntimeDeps = new Set(packageBundledRuntimeDependencies[pkg.name] ?? []);
     const forcedRuntimeDeps = packageRuntimeDependencies[pkg.name] ?? [];
     const forcedRuntimeDevDeps = packageRuntimeDevDependencies[pkg.name] ?? [];
     const [rootPackageJson, pkgJson] = await Promise.all([pkg.workspace.getPackageJson(), pkg.getPackageJson()]);
     const optionalPeerDeps = new Set(Object.entries(pkgJson.peerDependenciesMeta ?? {}).filter(([, meta]) => meta.optional).map(([dep]) => dep));
     const packageRuntimeDeps = [...new Set([...npmDeps, ...forcedRuntimeDeps])].filter((dep) => !optionalPeerDeps.has(dep) && !bundledRuntimeDeps.has(dep));
-    const packageRuntimeDevDeps = [...new Set([...npmDevDeps, ...forcedRuntimeDevDeps])].filter((dep) => !optionalPeerDeps.has(dep));
+    const packageRuntimeDevDeps = [...new Set([...npmDevDeps, ...forcedRuntimeDevDeps])].filter((dep) => !optionalPeerDeps.has(dep) && !bundledRuntimeDeps.has(dep));
     const rootDeps = { ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies };
     const missingForcedDeps = forcedRuntimeDeps.filter((dep) => !rootDeps[dep]);
     const missingForcedDevDeps = forcedRuntimeDevDeps.filter((dep) => !rootDeps[dep]);
@@ -268,7 +272,7 @@ class PackageRunner extends runner("package") {
     }
     if (!pkgJson.version)
       throw new Error(`[package] dist package version is missing for ${pkg.name}`);
-    if (!pkgJson.publishConfig || pkgJson.publishConfig.access !== "public") {
+    if (pkgJson.publishConfig?.access !== "public") {
       throw new Error(`[package] ${pkg.name} must publish with publishConfig.access=public`);
     }
     if (!await Bun.file(`${pkg.dist.cwdPath}/README.md`).exists()) {

package/{index-ec09pws3.js → index-8p8p0cf8.js}

@@ -1,22 +1,22 @@
 // @bun
 import {
-  pluralizeName
-} from "./index-ss469dec.js";
-import {
-  AiSession
-} from "./index-0cj2zxbm.js";
+  runner,
+  script
+} from "./index-znynzt5w.js";
 import {
-  createPassedPrimitiveReport,
   generatedFilesForSync,
+  createPassedPrimitiveReport,
   scalarChangedFiles
-} from "./index-rzwcpcc3.js";
+} from "./index-fc1bh0a7.js";
+import {
+  AiSession
+} from "./index-c69j78kk.js";
 import {
   Prompter
-} from "./index-tdbas9r0.js";
+} from "./index-h7yw2z9n.js";
 import {
-  runner,
-  script
-} from "./index-8hsbnyes.js";
+  pluralizeName
+} from "./index-nz8prx9g.js";
 
 // pkgs/@akanjs/cli/scalar/scalar.prompt.ts
 import { input } from "@inquirer/prompts";
@@ -192,9 +192,9 @@ class ScalarRunner extends runner("scalar") {
     const { request, validate } = await prompt.requestUpdateDictonaryWithInstruction();
     await session.writeTypescripts(request, sys, { validate });
     for (const scalarName of followingScalarNames) {
-      const prompt2 = new ScalarPrompt(sys, scalarName);
-      const { request: request2, validate: validate2 } = await prompt2.requestUpdateDictonaryWithFollowing();
-      await session.writeTypescripts(request2, sys, { validate: validate2 });
+      const prompt = new ScalarPrompt(sys, scalarName);
+      const { request, validate } = await prompt.requestUpdateDictonaryWithFollowing();
+      await session.writeTypescripts(request, sys, { validate });
     }
   }
 }

package/{index-wnp7hwq7.js → index-92zztqy1.js}

@@ -5,7 +5,7 @@ import * as path from "path";
 import chalk from "chalk";
 import * as ts from "typescript";
 
-class TypeChecker {
+class TypeChecker2 {
   configPath;
   configFile;
   config;
@@ -143,12 +143,12 @@ ${summary.join(", ")} found${output.join(`
     try {
       const { diagnostics } = this.check(filePath);
       return diagnostics.length === 0;
-    } catch (error) {
+    } catch (_error) {
       return false;
     }
   }
   static checkProject(configPath) {
-    const parsedConfig = TypeChecker.parseConfig(configPath);
+    const parsedConfig = TypeChecker2.parseConfig(configPath);
     const host = ts.createIncrementalCompilerHost(parsedConfig.options);
     const builderProgram = ts.createIncrementalProgram({
       rootNames: parsedConfig.fileNames,
@@ -166,19 +166,19 @@ ${summary.join(", ")} found${output.join(`
       diagnostics,
       errors,
       warnings,
-      message: TypeChecker.formatDiagnosticMessages(diagnostics)
+      message: TypeChecker2.formatDiagnosticMessages(diagnostics)
     };
   }
   static parseConfig(configPath) {
     const configFile = ts.readConfigFile(configPath, (fileName) => ts.sys.readFile(fileName));
     const configDiagnostics = configFile.error ? [configFile.error] : [];
     if (!configFile.config) {
-      const message = TypeChecker.formatDiagnosticMessages(configDiagnostics);
+      const message = TypeChecker2.formatDiagnosticMessages(configDiagnostics);
       throw new Error(message || `Error reading tsconfig.json: ${configPath}`);
     }
     const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath), undefined, configPath);
     if (parsedConfig.errors.length > 0)
-      throw new Error(TypeChecker.formatDiagnosticMessages(parsedConfig.errors));
+      throw new Error(TypeChecker2.formatDiagnosticMessages(parsedConfig.errors));
     return parsedConfig;
   }
   static formatDiagnosticMessages(diagnostics) {
@@ -190,4 +190,4 @@ ${summary.join(", ")} found${output.join(`
   }
 }
 
-export { TypeChecker };
+export { TypeChecker2 };

package/{index-fgc8r6dj.js → index-a5vmm6x4.js}

@@ -19,12 +19,14 @@ var prepareDevWatchBatch = ({
     generatedFiles: indexSync.changedFiles
   });
   if (indexSync.errors.length > 0 && !devPlan.actions.includes("report-error")) {
-    devPlan.actions = [...devPlan.actions, "report-error"].sort();
+    const withReport = [...devPlan.actions, "report-error"];
+    devPlan.actions = withReport.sort();
   }
   return {
     files,
     kinds,
     expandedBatch,
+    devPlan,
     event: { type: "invalidate", kinds, files, generation, devPlan },
     hasSyncErrors: indexSync.errors.length > 0
   };

package/{index-xys926f2.js → index-by5gpp8x.js}

@@ -2,7 +2,7 @@
 // pkgs/@akanjs/devkit/recipeScanner.ts
 import { readdir } from "fs/promises";
 import ts from "typescript";
-var collectRecipeSources = async (uiDirPath, importFrom, basename = "Recipe") => {
+var collectRecipeSources2 = async (uiDirPath, importFrom, basename = "Recipe") => {
   const read = async (filePath) => {
     const content = await Bun.file(filePath).text().catch(() => "");
     return content ? { path: filePath, content, importFrom } : null;
@@ -12,7 +12,7 @@ var collectRecipeSources = async (uiDirPath, importFrom, basename = "Recipe") =>
   const fromDir = await Promise.all(dirEntries.filter((entry) => entry.endsWith(".ts") && entry !== "index.ts" && !/\.(test|spec)\.ts$/.test(entry)).sort().map((entry) => read(`${uiDirPath}/${basename}/${entry}`)));
   return [flat, ...fromDir].filter((source) => !!source);
 };
-var scanRecipes = (sources) => {
+var scanRecipes2 = (sources) => {
   const recipes = [];
   for (const source of sources) {
     const sourceFile = ts.createSourceFile(source.path, source.content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
@@ -87,7 +87,7 @@ var isNamed = (name) => ts.isIdentifier(name) || ts.isStringLiteral(name);
 var propName = (name) => name.text;
 var DUPLICATE_TOKEN_RATIO = 0.7;
 var MIN_FINGERPRINT_TOKENS = 3;
-var findInlineRecipeDuplicates = (recipes, files) => {
+var findInlineRecipeDuplicates2 = (recipes, files) => {
   const fingerprints = recipes.map((recipe) => ({ recipe: recipe.name, tokens: (recipe.base ?? "").split(/\s+/).filter(Boolean) })).filter((fingerprint) => fingerprint.tokens.length >= MIN_FINGERPRINT_TOKENS).map((fingerprint) => ({ ...fingerprint, needed: Math.ceil(fingerprint.tokens.length * DUPLICATE_TOKEN_RATIO) }));
   if (fingerprints.length === 0)
     return [];
@@ -133,4 +133,4 @@ var getLeadingDoc = (fullText, node) => {
   return line || undefined;
 };
 
-export { collectRecipeSources, scanRecipes, findInlineRecipeDuplicates };
+export { collectRecipeSources2, scanRecipes2, findInlineRecipeDuplicates2 };

package/{index-0cj2zxbm.js → index-c69j78kk.js}

@@ -1,13 +1,13 @@
 // @bun
-import {
-  Spinner
-} from "./index-mxvakhsm.js";
 import {
   FileSys
-} from "./index-67546d0j.js";
+} from "./index-q0y2jq9j.js";
+import {
+  Spinner
+} from "./index-qsq3q8fy.js";
 
 // pkgs/@akanjs/devkit/cloud/globalConfig.ts
-import { mkdir } from "fs/promises";
+import { chmod, mkdir } from "fs/promises";
 import dayjs from "dayjs";
 
 // pkgs/@akanjs/devkit/cloud/constants.ts
@@ -34,8 +34,9 @@ class GlobalConfig {
     };
   }
   static async#setAkanGlobalConfig(akanConfig) {
-    await mkdir(basePath, { recursive: true });
+    await mkdir(basePath, { recursive: true, mode: 448 });
     await Bun.write(configPath, JSON.stringify(akanConfig, null, 2));
+    await chmod(configPath, 384);
   }
   static async getHostConfig(host = GlobalConfig.akanCloudHost) {
     const akanConfig = await GlobalConfig.#getAkanGlobalConfig();
@@ -240,7 +241,7 @@ import { ChatOpenAI } from "@langchain/openai";
 import { Logger } from "akanjs/common";
 import chalk from "chalk";
 var MAX_ASK_TRY = 300;
-var deepSeekLlmModels = ["deepseek-chat", "deepseek-reasoner"];
+var deepSeekLlmModels = ["deepseek-v4-flash", "deepseek-v4-pro"];
 var openAiLlmModels = ["gpt-5.5"];
 var supportedLlmModels = [...deepSeekLlmModels, ...openAiLlmModels];
 var isOpenAiLlmModel = (model) => openAiLlmModels.includes(model);
@@ -275,10 +276,10 @@ class AiSession {
   static #chat = null;
   static async init({ temperature = 0, useExisting = true } = {}) {
     if (useExisting) {
-      const llmConfig2 = await AiSession.getLlmConfig();
-      if (llmConfig2) {
-        AiSession.#setChatModel(llmConfig2.model, llmConfig2.apiKey);
-        Logger.rawLog(chalk.dim(`\uD83E\uDD16akan editor uses existing LLM config (${llmConfig2.model})`));
+      const llmConfig = await AiSession.getLlmConfig();
+      if (llmConfig) {
+        AiSession.#setChatModel(llmConfig.model, llmConfig.apiKey);
+        Logger.rawLog(chalk.dim(`\uD83E\uDD16akan editor uses existing LLM config (${llmConfig.model})`));
         return AiSession;
       }
     } else

package/{index-rzwcpcc3.js → index-fc1bh0a7.js}

@@ -2,7 +2,7 @@
 import {
   AppExecutor,
   LibExecutor
-} from "./index-hgna5rjy.js";
+} from "./index-qsq3q8fy.js";
 
 // pkgs/@akanjs/devkit/workflow/utils.ts
 var jsonText = (value, { trailingNewline = true } = {}) => `${JSON.stringify(value, null, 2)}${trailingNewline ? `
@@ -914,9 +914,9 @@ ${options.closingIndent}}`);
   const beforeField = locator.fields[insertIndex];
   if (beforeField) {
     const leadingComments = ts.getLeadingCommentRanges(content, beforeField.fullStart) ?? [];
-    const insertAt2 = lineStartAt(content, leadingComments[0]?.pos ?? beforeField.start);
-    const indent2 = lineIndentAt(content, beforeField.start) || options.fieldIndent;
-    return spliceText(content, insertAt2, insertAt2, `${indent2}${formattedLine}
+    const insertAt = lineStartAt(content, leadingComments[0]?.pos ?? beforeField.start);
+    const indent = lineIndentAt(content, beforeField.start) || options.fieldIndent;
+    return spliceText(content, insertAt, insertAt, `${indent}${formattedLine}
 `);
   }
   const afterField = locator.fields[locator.fields.length - 1];

package/{index-7c6k4yvg.js → index-gq44bqjt.js}

@@ -2,16 +2,24 @@
 import {
   runner,
   script
-} from "./index-8hsbnyes.js";
+} from "./index-znynzt5w.js";
 import {
   LibExecutor
-} from "./index-hgna5rjy.js";
+} from "./index-qsq3q8fy.js";
+import {
+  LibSource,
+  formatLibStatuses
+} from "./index-3d9y066c.js";
+
+// pkgs/@akanjs/cli/library/library.script.ts
+import { Logger } from "akanjs/common";
 
-// pkgs/@akanjs/cli/semver.ts
-function parseVersion(version) {
+// pkgs/@akanjs/devkit/semver.ts
+var stripRangeOperator = (version) => version.replace(/^[\s^~>=<v]+/, "").trim();
+var parseVersion = (version) => {
   return version.replace(/^[^\d]*/, "").split(/[.-]/).map((part) => Number.parseInt(part, 10)).map((part) => Number.isFinite(part) ? part : 0);
-}
-function compareSemver(a, b) {
+};
+var compareNumeric = (a, b) => {
   const left = parseVersion(a);
   const right = parseVersion(b);
   const length = Math.max(left.length, right.length);
@@ -21,40 +29,64 @@ function compareSemver(a, b) {
       return diff > 0 ? 1 : -1;
   }
   return 0;
-}
+};
+var compareSemver = (a, b) => {
+  try {
+    return Bun.semver.order(stripRangeOperator(a), stripRangeOperator(b));
+  } catch {
+    return compareNumeric(a, b);
+  }
+};
 
 // pkgs/@akanjs/cli/library/library.runner.ts
 class LibraryRunner extends runner("library") {
+  static libraryRepository = "https://github.com/akan-team/akanjs.git";
   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`;
     if (!await workspace.exists(installedPackageJson))
-      return false;
+      return null;
     await workspace.cp(`node_modules/akanjs/libs/${libName}`, `libs/${libName}`);
-    return true;
+    return { origin: "akanjs", sha: await this.#installedAkanVersion(workspace) };
+  }
+  async#installedAkanVersion(workspace) {
+    const manifestPath = "node_modules/akanjs/package.json";
+    if (!await workspace.exists(manifestPath))
+      return "unknown";
+    const { version } = await workspace.readJson(manifestPath);
+    return version ?? "unknown";
   }
   async#copyLibraryFromRepository(workspace, libName) {
     await workspace.mkdir("node_modules/.akan");
     if (await workspace.exists("node_modules/.akan/akanjs"))
       await workspace.removeDir("node_modules/.akan/akanjs");
-    await workspace.exec(`cd node_modules/.akan && git clone https://github.com/akan-team/akanjs.git`);
+    await workspace.exec(`cd node_modules/.akan && git clone ${LibraryRunner.libraryRepository}`);
     await workspace.cp(`node_modules/.akan/akanjs/libs/${libName}`, `libs/${libName}`);
+    const sha = await workspace.spawn("git", ["-C", "node_modules/.akan/akanjs", "rev-parse", "HEAD"]);
+    return { origin: LibraryRunner.libraryRepository, sha: sha.trim().slice(0, 12) };
   }
   async installLibrary(workspace, libName) {
-    const copiedFromInstalledPackage = await this.#copyInstalledLibrary(workspace, libName);
-    if (!copiedFromInstalledPackage)
-      await this.#copyLibraryFromRepository(workspace, libName);
-    await workspace.cp(`libs/${libName}/env/env.server.example.ts`, `libs/${libName}/env/env.server.testing.ts`);
-    await workspace.commit(`Add ${libName} library`);
-    return LibExecutor.from(workspace, libName);
+    const source = await this.#copyInstalledLibrary(workspace, libName) ?? await this.#copyLibraryFromRepository(workspace, libName);
+    const testingEnv = `libs/${libName}/env/env.server.testing.ts`;
+    if (!await workspace.exists(testingEnv))
+      await workspace.cp(`libs/${libName}/env/env.server.example.ts`, testingEnv);
+    const lib = LibExecutor.from(workspace, libName);
+    const stamp = await new LibSource(lib).write(source);
+    if (await workspace.hasChanges())
+      await workspace.commit(`Install ${libName} library from ${stamp.origin}`);
+    return lib;
+  }
+  async libraryStatuses(workspace) {
+    const libNames = await workspace.getLibs();
+    return await Promise.all(libNames.map((libName) => new LibSource(LibExecutor.from(workspace, libName)).status()));
   }
   async mergeLibraryDependencies(lib) {
     const libPackageJson = await lib.getPackageJson();
@@ -70,7 +102,7 @@ class LibraryRunner extends runner("library") {
       return [dep, newerVersion];
     }));
     Object.keys(allDependencies).sort().forEach((dep) => {
-      if (!!libPackageJson.dependencies?.[dep] || !!rootPackageJson.dependencies?.[dep])
+      if (libPackageJson.dependencies?.[dep] || rootPackageJson.dependencies?.[dep])
         dependencies[dep] = allDependencies[dep];
       else
         devDependencies[dep] = allDependencies[dep];
@@ -80,7 +112,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
@@ -102,6 +133,13 @@ class LibraryScript extends script("library", [LibraryRunner]) {
     await this.libraryRunner.removeLibrary(lib);
     spinner.succeed(`Library ${lib.name} (libs/${lib.name}) is removed`);
   }
+  async libraryStatus(workspace, format = "text") {
+    const spinner = workspace.spinning("Checking library sources...");
+    const statuses = await this.libraryRunner.libraryStatuses(workspace);
+    const drifted = statuses.filter((status) => status.drift === "drifted").length;
+    spinner.succeed(`Checked ${statuses.length} libraries (${drifted} drifted)`);
+    Logger.rawLog(format === "json" ? JSON.stringify(statuses, null, 2) : formatLibStatuses(statuses));
+  }
   async installLibrary(workspace, libName) {
     const installSpinner = workspace.spinning(`Installing ${libName} library`);
     const lib = await this.libraryRunner.installLibrary(workspace, libName);
@@ -110,11 +148,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 };