akanjs 2.0.0-beta.1 → 2.0.0-beta.10

package/cli/application/application.command.ts

@@ -1,5 +1,5 @@
 import { select } from "@inquirer/prompts";
-import { App, command, Exec, Sys, Workspace } from "akanjs/devkit";
+import { App, command, Exec, getMobileTargetChoices, Sys, Workspace } from "akanjs/devkit";
 
 import { ApplicationScript } from "./application.script";
 
@@ -53,7 +53,11 @@ export class ApplicationCommand extends command("application", [ApplicationScrip
     }),
   buildIos: target({ short: true, desc: "Build iOS app with Capacitor" })
     .with(App)
-    .option("target", String, { desc: "mobile target name or all" })
+    .option("target", String, {
+      desc: "mobile target name or all",
+      ask: "Select mobile target",
+      enum: async ({ app }) => await getMobileTargetChoices(app),
+    })
     .option("env", String, {
       enum: ["local", "debug", "develop", "main"],
       desc: "backend environment",
@@ -66,7 +70,11 @@ export class ApplicationCommand extends command("application", [ApplicationScrip
     }),
   buildAndroid: target({ short: true, desc: "Build Android app with Capacitor" })
     .with(App)
-    .option("target", String, { desc: "mobile target name or all" })
+    .option("target", String, {
+      desc: "mobile target name or all",
+      ask: "Select mobile target",
+      enum: async ({ app }) => await getMobileTargetChoices(app),
+    })
     .option("env", String, {
       enum: ["local", "debug", "develop", "main"],
       desc: "backend environment",

package/cli/guidelines/databaseModule/databaseModule.instruction.md

@@ -94,7 +94,7 @@ Create the MongoDB schema with document methods and middleware:
 
 ```typescript
 import { dayjs } from "akanjs/base";
-import { beyond, by, Database, into, Loader, type SchemaOf } from "akanjs/document";
+import { by, Database, into, Loader, type SchemaOf } from "akanjs/document";
 import { hashPassword } from "@libs/shared/server";
 
 import * as cnst from "../cnst";

package/cli/guidelines/modelConstant/modelConstant.instruction.md

@@ -80,7 +80,7 @@ export class Drone extends Full(DroneObject, LightDrone) {
 // 7. Insight Model
 
 export class DroneInsight {
-  @Field.Prop(() => Int, { default: 0, accumulate: { $sum: 1 } })
+  @Field.Prop(() => Int, { default: 0, accumulate: {} })
   count: number;
 }
 
@@ -223,7 +223,7 @@ Insight model defines statistical fields:
 
 ```typescript
 export class DroneInsight {
-  @Field.Prop(() => Int, { default: 0, accumulate: { $sum: 1 } })
+  @Field.Prop(() => Int, { default: 0, accumulate: {} })
   count: number;
 }
 ```
@@ -314,8 +314,8 @@ const drones = await this.listByName("myDrone", { sort: "alphabetical" });
 | `enum`       | `any[]`              | -       | Enum values restriction                | `@Field.Prop(()=> String, { enum: ["active","inactive"] }) status;`    |
 | `minlength`  | `number`             | -       | Minimum string length                  | `@Field.Prop(()=> String, { minlength: 2 }) name: string;`             |
 | `maxlength`  | `number`             | -       | Maximum string length                  | `@Field.Prop(()=> String, { maxlength: 30 }) title: string;`           |
-| `query`      | `object`             | -       | Query value for Summary fields         | `@Field.Prop(() => Int, { query: { status: { $ne: 'inactive' } })`     |
-| `accumulate` | `object`             | -       | Aggregation value for Insight fields   | `@Field.Prop(() => Int, { accumulate: { $sum: 1 } }) count: number;`   |
+| `query`      | `object`             | -       | Query value for Summary fields         | `@Field.Prop(() => Int, { query: { status: { ne: "inactive" } } })`     |
+| `accumulate` | `object`             | -       | Document query filter for Insight count fields | `@Field.Prop(() => Int, { accumulate: { status: "active" } }) activeCount: number;` |
 | `example`    | `any`                | -       | Example value for API docs             | `@Field.Prop(()=> String, { example: "contact@akanjs.com" }) email;`   |
 | `of`         | `any`                | -       | Value type for Map fields              | `@Field.Prop(()=> Map, { of: Date }) readAts: Map<string, Dayjs>;`     |
 | `validate`   | `(value) => boolean` | -       | Custom validation function             | `@Field.Prop(()=> String, { validate: (v)=> v.includes("@") }) email;` |
@@ -477,7 +477,7 @@ export class Drone extends Full(DroneObject, LightDrone) {
 // Insight Model
 
 export class DroneInsight {
-  @Field.Prop(() => Int, { accumulate: { $sum: 1 } })
+  @Field.Prop(() => Int, { accumulate: {} })
   count: number;
 }
 

package/cli/guidelines/modelDocument/modelDocument.instruction.md

@@ -118,26 +118,14 @@ export class OrderModel extends into(Order, cnst.orderCnst) {
       .save();
   }
 
-  // Aggregation example
+  // Insight-style count example
   async getOrderStatsByUser(userId: string) {
-    const result = await this.Order.aggregate([
-      { $match: { user: userId } },
-      {
-        $group: {
-          _id: "$status",
-          count: { $sum: 1 },
-          totalAmount: { $sum: "$totalAmount" },
-        },
-      },
-    ]);
-
-    return result.reduce((acc, item) => {
-      acc[item._id] = {
-        count: item.count,
-        totalAmount: item.totalAmount,
-      };
-      return acc;
-    }, {});
+    const baseQuery = { user: userId };
+
+    return {
+      active: await this.count({ ...baseQuery, status: "active" }),
+      refunded: await this.count({ ...baseQuery, status: "refunded" }),
+    };
   }
 }
 ```
@@ -191,37 +179,30 @@ Indexes are crucial for query performance. Define them in the Middleware's `onSc
 - **Unique index** - Ensure field values are unique across the collection
 - **Sparse index** - Only include documents that have the indexed field
 
-## How to Use MongoDB Model
+## How to Query Documents
 
-The Akan.js framework provides direct access to the Mongoose model, allowing you to perform standard MongoDB operations:
+The Akan.js framework uses document query objects for common filtering and counting:
 
 ```typescript
 // Find operations
-const product = await productModel.Product.findById(id);
-const activeProducts = await productModel.Product.find({ status: "active" });
+const product = await productModel.pickById(id);
+const activeProducts = await productModel.list({ status: "active" });
 
 // Update operations
-await productModel.Product.updateMany({ category: "electronics" }, { $set: { onSale: true } });
+await productModel.updateManyByQuery({ category: "electronics" }, { set: { onSale: true } });
 
-// Aggregation
-const stats = await productModel.Product.aggregate([
-  { $match: { status: "active" } },
-  {
-    $group: {
-      _id: "$category",
-      count: { $sum: 1 },
-      avgPrice: { $avg: "$price" },
-    },
-  },
-]);
+// Insight counts
+const activeCount = await productModel.count({ status: "active" });
+const categoryCount = await productModel.count({ category: "electronics" });
 
 // Advanced querying
-const products = await productModel.Product.find({
-  price: { $gte: 100, $lte: 500 },
-  category: { $in: ["electronics", "gadgets"] },
-})
-  .sort({ rating: -1 })
-  .limit(10);
+const products = await productModel.list(
+  {
+    price: { gte: 100, lte: 500 },
+    category: { oneOf: ["electronics", "gadgets"] },
+  },
+  { sort: { rating: -1 }, limit: 10 },
+);
 ```
 
 ## How to Use DataLoader
@@ -422,16 +403,17 @@ export class ProductModel extends into(Product, cnst.productCnst) {
   tagProductsLoader: Loader<string, Product[]>;
 
   async findPopularProducts(limit = 10) {
-    return this.Product.find({
+    return this.list(
+      {
       status: "active",
-      popularity: { $gte: 4 },
-    })
-      .sort({ popularity: -1 })
-      .limit(limit);
+        popularity: { gte: 4 },
+      },
+      { sort: { popularity: -1 }, limit },
+    );
   }
 
   async updatePrices(categoryId: string, increasePercentage: number) {
-    const products = await this.Product.find({ category: categoryId });
+    const products = await this.list({ category: categoryId });
 
     const updates = products.map((product) => {
       const newPrice = product.price * (1 + increasePercentage / 100);
@@ -441,20 +423,11 @@ export class ProductModel extends into(Product, cnst.productCnst) {
     return Promise.all(updates);
   }
 
-  async getCategoryStats() {
-    const result = await this.Product.aggregate([
-      { $match: { status: "active" } },
-      {
-        $group: {
-          _id: "$category",
-          count: { $sum: 1 },
-          avgPrice: { $avg: "$price" },
-          minPrice: { $min: "$price" },
-          maxPrice: { $max: "$price" },
-        },
-      },
-      { $sort: { count: -1 } },
-    ]);
+  async getCategoryStats(categoryId: string) {
+    const result = {
+      activeCount: await this.count({ status: "active", category: categoryId }),
+      popularCount: await this.count({ status: "active", category: categoryId, popularity: { gte: 4 } }),
+    };
 
     // Cache the results
     await this.ProductCache.set("stats", "categories", JSON.stringify(result), { expireAt: dayjs().add(1, "hour") });

package/cli/guidelines/modelService/modelService.instruction.md

@@ -644,7 +644,7 @@ export class OrderService extends DbService(db.orderDb) {
     // Return stock to inventory
     for (const item of order.items) {
       await this.productService.updateProduct(item.product, {
-        $inc: { stock: item.quantity },
+        inc: { stock: item.quantity },
       });
     }
 

package/cli/index.js

@@ -4816,6 +4816,9 @@ var rewriteSingleStatement = (stmt, map) => {
     return null;
   const lines = [];
   const tail = ";";
+  if (shouldPreserveBarrelSideEffects(stmt.specifier)) {
+    lines.push(`import "${stmt.specifier}"${tail}`);
+  }
   if (clause.defaultImport || remaining.length > 0) {
     const parts = [];
     if (clause.defaultImport)
@@ -4831,6 +4834,7 @@ var rewriteSingleStatement = (stmt, map) => {
   return lines.join(`
 `);
 };
+var shouldPreserveBarrelSideEffects = (specifier) => /^@(apps|libs)\/[^/]+\/client$/.test(specifier);
 var serializeNamedItem = (item) => {
   const prefix = item.isType ? "type " : "";
   if (item.imported === item.local)
@@ -6048,6 +6052,8 @@ class CssImportResolver {
 
 var SOURCE_EXTS3 = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
 var NON_SOURCE_EXT_RE3 = /\.(json|svg|png|jpe?g|webp|gif|avif|ico|woff2?|ttf|otf|mp3|mp4|wav)$/i;
+var NODE_MODULES_RE3 = /[\\/]node_modules[\\/]/;
+var AKANJS_NODE_MODULE_RE3 = /[\\/]node_modules[\\/]akanjs[\\/]/;
 
 class CssCompiler {
   #logger = new Logger("CssCompiler");
@@ -6115,7 +6121,7 @@ class CssCompiler {
     const akanConfig2 = await this.#app.getConfig({ refresh });
     while (queue.length > 0) {
       const filePath = queue.shift();
-      if (!filePath || sourceFiles.has(filePath) || filePath.includes("node_modules"))
+      if (!filePath || sourceFiles.has(filePath) || isIgnoredNodeModuleSource(filePath))
         continue;
       sourceFiles.add(filePath);
       let content;
@@ -6151,7 +6157,7 @@ class CssCompiler {
         if (NON_SOURCE_EXT_RE3.test(spec))
           continue;
         const resolved = await this.#resolveSourceImport(spec, importerDir, resolvePackage);
-        if (!resolved || sourceFiles.has(resolved) || resolved.includes("node_modules"))
+        if (!resolved || sourceFiles.has(resolved) || isIgnoredNodeModuleSource(resolved))
           continue;
         queue.push(resolved);
       }
@@ -6239,7 +6245,7 @@ class CssCompiler {
     const files = new Set(sourcePaths);
     await Promise.all(dirs.map(async (dir) => {
       for await (const file of glob.scan({ cwd: dir, absolute: true })) {
-        if (file.includes("node_modules"))
+        if (isIgnoredNodeModuleSource(file))
           continue;
         files.add(file);
       }
@@ -6286,6 +6292,9 @@ function resolveSourceWithRequire(id, fromBase) {
 function isSourceFile(filePath) {
   return SOURCE_EXTS3.includes(path23.extname(filePath));
 }
+function isIgnoredNodeModuleSource(filePath) {
+  return NODE_MODULES_RE3.test(filePath) && !AKANJS_NODE_MODULE_RE3.test(filePath);
+}
 function getPageKeyBasePath(pageKey, basePaths) {
   const normalized = pageKey.split(path23.sep).join("/").replace(/^\.\//, "");
   const segments = normalized.split("/");
@@ -7903,21 +7912,65 @@ var getMobileTargets = async (app) => {
   const config = await app.getConfig();
   return Object.entries(config.mobile.targets).map(([name, target]) => ({ name, config: target }));
 };
+var getMobileTargetChoices = async (app) => {
+  const config = await app.getConfig();
+  const targetNames = Object.keys(config.mobile.targets);
+  if (targetNames.length > 1)
+    return targetNames;
+  const basePaths = [...config.basePaths];
+  if (basePaths.length > 1)
+    return basePaths;
+  if (targetNames.length > 0)
+    return targetNames;
+  return basePaths;
+};
+var resolveMobileTargetByBasePath = (targets, basePath2) => {
+  const normalizedBasePath = basePath2.replace(/^\/+|\/+$/g, "");
+  const byBasePath = targets.find((target) => target.config.basePath?.replace(/^\/+|\/+$/g, "") === normalizedBasePath);
+  if (byBasePath)
+    return byBasePath;
+  const [template] = targets;
+  if (!template)
+    return;
+  return {
+    name: template.name,
+    config: {
+      ...template.config,
+      basePath: normalizedBasePath
+    }
+  };
+};
 var resolveMobileTargets = async (app, selection) => {
+  const config = await app.getConfig();
   const targets = await getMobileTargets(app);
   if (targets.length === 0)
     throw new Error(`No mobile targets configured for ${app.name}`);
   if (!selection) {
-    if (targets.length === 1)
-      return targets;
-    throw new Error(`Multiple mobile targets found for ${app.name}. Pass --target <${targets.map((t) => t.name).join("|")}|all>.`);
+    const choices2 = await getMobileTargetChoices(app);
+    if (choices2.length === 1)
+      return resolveMobileTargets(app, choices2[0]);
+    throw new Error(`Multiple mobile targets found for ${app.name}. Pass --target <${choices2.join("|")}|all>.`);
   }
-  if (selection === "all")
+  if (selection === "all") {
+    if (Object.keys(config.mobile.targets).length > 1)
+      return targets;
+    const basePaths = [...config.basePaths];
+    if (basePaths.length > 1) {
+      return basePaths.flatMap((basePath2) => {
+        const resolved = resolveMobileTargetByBasePath(targets, basePath2);
+        return resolved ? [resolved] : [];
+      });
+    }
     return targets;
+  }
   const target = targets.find((candidate) => candidate.name === selection);
-  if (!target)
-    throw new Error(`Mobile target '${selection}' was not found. Available: ${targets.map((t) => t.name).join(", ")}`);
-  return [target];
+  if (target)
+    return [target];
+  const basePathTarget = resolveMobileTargetByBasePath(targets, selection);
+  if (basePathTarget && config.basePaths.has(selection.replace(/^\/+|\/+$/g, "")))
+    return [basePathTarget];
+  const choices = await getMobileTargetChoices(app);
+  throw new Error(`Mobile target '${selection}' was not found. Available: ${choices.join(", ")}`);
 };
 var resolveMobilePath = (target, pathname) => {
   const basePath2 = target.basePath?.replace(/^\/+|\/+$/g, "");
@@ -8114,7 +8167,8 @@ class CapacitorApp {
   async#writeCapacitorConfig() {
     await mkdir10(this.targetRoot, { recursive: true });
     const appInfoPath = path34.relative(this.targetRoot, path34.join(this.app.cwdPath, "akan.app.json")).split(path34.sep).join("/");
-    const content = `import { withBase } from "akanjs/devkit/capacitor.base.config";
+    const baseConfigPath = path34.relative(this.targetRoot, path34.join(this.app.workspace.cwdPath, "pkgs/akanjs/devkit/capacitor.base.config")).split(path34.sep).join("/");
+    const content = `import { withBase } from "${baseConfigPath.startsWith(".") ? baseConfigPath : `./${baseConfigPath}`}";
 import appInfo from "${appInfoPath}";
 
 export default withBase((config) => config, appInfo, "${this.target.name}");
@@ -8564,7 +8618,7 @@ var formatCommandHelp = (command, key) => {
       const optName = `${flag}--${kebabName}`;
       const optDesc = opt.desc ?? "";
       const defaultVal = opt.default !== undefined ? chalk5.gray(` [default: ${String(opt.default)}]`) : "";
-      const choices = opt.enum ? chalk5.gray(` (${opt.enum.map(formatChoice).join(", ")})`) : "";
+      const choices = opt.enum ? chalk5.gray(typeof opt.enum === "function" ? " ([dynamic choices])" : ` (${opt.enum.map(formatChoice).join(", ")})`) : "";
       lines.push(`      ${chalk5.green(optName)}      ${chalk5.gray(optDesc)}${defaultVal}${choices}`);
     }
     lines.push("");
@@ -8584,7 +8638,7 @@ var handleOption = (programCommand, argMeta) => {
     ask
   } = argMeta.argsOption;
   const kebabName = camelToKebabCase2(argMeta.name);
-  const choices = enumChoices?.map((choice) => typeof choice === "object" ? { value: choice.value, name: choice.label } : { value: choice, name: choice.toString() });
+  const choices = enumChoices && typeof enumChoices !== "function" ? normalizeEnumChoices(enumChoices) : null;
   programCommand.option(`-${flag}, --${kebabName}${type === "boolean" ? " [boolean]" : ` <${kebabName}>`}`, `${desc}${ask ? ` (${ask})` : ""}${example ? ` (example: ${example})` : ""}${choices ? ` (choices: ${choices.map((choice) => choice.name).join(", ")})` : ""}`);
   return programCommand;
 };
@@ -8601,7 +8655,16 @@ var convertArgValue = (value, type) => {
   else
     return value === true || value === "true";
 };
-var getOptionValue = async (argMeta, opt) => {
+var normalizeEnumChoices = (enumChoices) => enumChoices.map((choice) => typeof choice === "object" ? { value: choice.value, name: choice.label } : { value: choice, name: choice.toString() });
+var resolveEnumChoices = async (argMeta, context) => {
+  const enumChoices = argMeta.argsOption.enum;
+  if (!enumChoices)
+    return null;
+  if (typeof enumChoices === "function")
+    return await enumChoices(context);
+  return enumChoices;
+};
+var getOptionValue = async (argMeta, opt, context) => {
   const {
     name,
     argsOption: { enum: enumChoices, default: defaultValue, type, desc, nullable, example, ask }
@@ -8610,13 +8673,13 @@ var getOptionValue = async (argMeta, opt) => {
     return convertArgValue(opt[argMeta.name], type ?? "string");
   else if (defaultValue !== undefined)
     return defaultValue;
-  else if (nullable)
-    return null;
   if (enumChoices) {
-    const choices = enumChoices.map((choice2) => typeof choice2 === "object" ? { value: choice2.value, name: choice2.label } : { value: choice2, name: choice2.toString() });
+    const choices = normalizeEnumChoices(await resolveEnumChoices(argMeta, context) ?? []);
     const choice = await select2({ message: ask ?? desc ?? `Select the ${name} value`, choices });
     return choice;
-  } else if (type === "boolean") {
+  } else if (nullable)
+    return null;
+  else if (type === "boolean") {
     const message = ask ?? desc ?? `Do you want to set ${name}? ${desc ? ` (${desc})` : ""}: `;
     return await confirm({ message });
   } else {
@@ -8641,6 +8704,22 @@ var getArgumentValue = async (argMeta, value) => {
   const message = ask ? `${ask}: ` : desc ? `${desc}: ` : `Enter the ${name} value${example ? ` (example: ${example})` : ""}: `;
   return convertArgValue(await input2({ message }), type ?? "string");
 };
+var assignCommandContext = (context, argMeta, value) => {
+  if (value instanceof AppExecutor)
+    context.app = value;
+  else if (value instanceof LibExecutor)
+    context.lib = value;
+  else if (value instanceof PkgExecutor)
+    context.pkg = value;
+  else if (value instanceof ModuleExecutor)
+    context.module = value;
+  else if (value instanceof Executor)
+    context.exec = value;
+  if (argMeta.type === "Argument" || argMeta.type === "Option")
+    context.values[argMeta.name] = value;
+  else
+    context.values[argMeta.type.toLowerCase()] = value;
+};
 var assertCurrentDirectoryIsWorkspaceRoot = async () => {
   const cwd = process.cwd();
   const [hasPackageJson, hasTsConfig, hasEnv] = await Promise.all([
@@ -8816,15 +8895,17 @@ It may cause unexpected behavior. Run \`akan update\` to update latest akanjs.`)
           if (targetMeta.targetOption.runsOnWorkspaceRoot)
             await assertCurrentDirectoryIsWorkspaceRoot();
           const workspace = WorkspaceExecutor.fromRoot();
+          const commandContext = { values: {} };
           for (const argMeta of allArgMetas) {
             if (argMeta.type === "Option")
-              commandArgs[argMeta.idx] = await getOptionValue(argMeta, opt);
+              commandArgs[argMeta.idx] = await getOptionValue(argMeta, opt, commandContext);
             else if (argMeta.type === "Argument")
               commandArgs[argMeta.idx] = await getArgumentValue(argMeta, cmdArgs[argMeta.idx]);
             else
               commandArgs[argMeta.idx] = await getInternalArgumentValue(argMeta, cmdArgs[argMeta.idx], workspace);
             if (commandArgs[argMeta.idx] instanceof AppExecutor)
               process.env.AKAN_PUBLIC_APP_NAME = commandArgs[argMeta.idx].name;
+            assignCommandContext(commandContext, argMeta, commandArgs[argMeta.idx]);
             if (opt.verbose)
               Executor.setVerbose(true);
           }
@@ -9846,14 +9927,22 @@ class ApplicationCommand extends command("application", [ApplicationScript], ({
   test: target({ desc: "Prepare and test an app, library, or package" }).with(Exec).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(exec2, write) {
     await this.applicationScript.test(exec2, { write });
   }),
-  buildIos: target({ short: true, desc: "Build iOS app with Capacitor" }).with(App).option("target", String, { desc: "mobile target name or all" }).option("env", String, {
+  buildIos: target({ short: true, desc: "Build iOS app with Capacitor" }).with(App).option("target", String, {
+    desc: "mobile target name or all",
+    ask: "Select mobile target",
+    enum: async ({ app }) => await getMobileTargetChoices(app)
+  }).option("env", String, {
     enum: ["local", "debug", "develop", "main"],
     desc: "backend environment",
     default: "debug"
   }).option("write", Boolean, { desc: "write code generation", default: true }).option("regenerate", Boolean, { flag: "g", desc: "delete and regenerate native project", default: false }).exec(async function(app, target2, env, write, regenerate) {
     await this.applicationScript.buildIos(app, { target: target2, env: asMobileEnv(env), write, regenerate });
   }),
-  buildAndroid: target({ short: true, desc: "Build Android app with Capacitor" }).with(App).option("target", String, { desc: "mobile target name or all" }).option("env", String, {
+  buildAndroid: target({ short: true, desc: "Build Android app with Capacitor" }).with(App).option("target", String, {
+    desc: "mobile target name or all",
+    ask: "Select mobile target",
+    enum: async ({ app }) => await getMobileTargetChoices(app)
+  }).option("env", String, {
     enum: ["local", "debug", "develop", "main"],
     desc: "backend environment",
     default: "debug"
@@ -9946,13 +10035,16 @@ class ApplicationCommand extends command("application", [ApplicationScript], ({
 })) {
 }
 
+import path36 from "path";
 var {$: $2 } = globalThis.Bun;
 
 class PackageRunner extends runner("package") {
-  async version(workspace) {
-    const pkgJson = await FileSys.readJson("package.json");
+  async version(workspace, { log = true } = {}) {
+    const pkgJson = await FileSys.readJson(process.env.USE_AKANJS_PKGS === "true" ? `${workspace.workspaceRoot}/pkgs/akanjs/package.json` : `${path36.dirname(Bun.main)}/../package.json`);
     const version = pkgJson.version;
-    Logger.rawLog(`${pkgJson.name}@${version}`);
+    if (log)
+      Logger.rawLog(`${pkgJson.name}@${version}`);
+    return version;
   }
   async createPackage(workspace, pkgName) {
     await workspace.applyTemplate({ basePath: `pkgs/${pkgName}`, template: "pkgRoot", dict: { pkgName } });
@@ -9971,15 +10063,26 @@ class PackageRunner extends runner("package") {
     await pkg.dist.mkdir(pkg.dist.cwdPath);
     const scanner = await TypeScriptDependencyScanner.from(pkg);
     const { npmDeps, npmDevDeps, missingDeps } = await scanner.getPackageBuildDependencies(pkg.name);
-    if (missingDeps.length > 0)
-      throw new Error(`Missing dependency versions in root package.json: ${missingDeps.join(", ")}`);
-    await pkg.updatePackageJsonDependencies(npmDeps, npmDevDeps);
+    const packageRuntimeDependencies = { akanjs: ["daisyui"] };
+    const packageRuntimeDevDependencies = { akanjs: ["@biomejs/biome"] };
+    const forcedRuntimeDeps = packageRuntimeDependencies[pkg.name] ?? [];
+    const forcedRuntimeDevDeps = packageRuntimeDevDependencies[pkg.name] ?? [];
+    const packageRuntimeDeps = [...new Set([...npmDeps, ...forcedRuntimeDeps])];
+    const packageRuntimeDevDeps = [...new Set([...npmDevDeps, ...forcedRuntimeDevDeps])];
+    const rootPackageJson = await pkg.workspace.getPackageJson();
+    const rootDeps = { ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies };
+    const missingForcedDeps = forcedRuntimeDeps.filter((dep) => !rootDeps[dep]);
+    const missingForcedDevDeps = forcedRuntimeDevDeps.filter((dep) => !rootDeps[dep]);
+    const allMissingDeps = [...new Set([...missingDeps, ...missingForcedDeps, ...missingForcedDevDeps])].sort();
+    if (allMissingDeps.length > 0)
+      throw new Error(`Missing dependency versions in root package.json: ${allMissingDeps.join(", ")}`);
+    await pkg.updatePackageJsonDependencies(packageRuntimeDeps, packageRuntimeDevDeps);
     const hasBuildFile = await Bun.file(`${pkg.cwdPath}/build.ts`).exists();
     if (hasBuildFile) {
       await pkg.workspace.spawn(process.execPath, [`${pkg.cwdPath}/build.ts`], { env: process.env, stdio: "inherit" });
     } else {
       await $2`cp -r ${pkg.cwdPath}/. ${pkg.dist.cwdPath}`;
-      await Promise.all([pkg.generateDistPackageJson(npmDeps, npmDevDeps), pkg.generateTsconfigJson()]);
+      await Promise.all([pkg.generateDistPackageJson(packageRuntimeDeps, packageRuntimeDevDeps), pkg.generateTsconfigJson()]);
     }
   }
   async updateWorskpaceRootPackageJson(workspace, rootPackageJson) {
@@ -9996,8 +10099,8 @@ class PackageRunner extends runner("package") {
 }
 
 class PackageScript extends script("package", [PackageRunner]) {
-  async version(workspace) {
-    await this.packageRunner.version(workspace);
+  async version(workspace, { log = true } = {}) {
+    return await this.packageRunner.version(workspace, { log });
   }
   async createPackage(workspace, pkgName) {
     const spinner2 = workspace.spinning(`Creating package in pkgs/${pkgName}...`);
@@ -10256,14 +10359,14 @@ class GuidelinePrompt extends Prompter {
   async#getScanFilePaths(matchPattern, { avoidDirs = ["node_modules", ".next"], filterText } = {}) {
     const glob = new Bun.Glob(matchPattern);
     const paths = [];
-    for await (const path36 of glob.scan({ cwd: this.workspace.workspaceRoot, absolute: true })) {
-      if (avoidDirs.some((dir) => path36.includes(dir)))
+    for await (const path37 of glob.scan({ cwd: this.workspace.workspaceRoot, absolute: true })) {
+      if (avoidDirs.some((dir) => path37.includes(dir)))
         continue;
-      const fileContent = await FileSys.readText(path36);
+      const fileContent = await FileSys.readText(path37);
       const textFilter = filterText ? new RegExp(filterText) : null;
       if (filterText && !textFilter?.test(fileContent))
         continue;
-      paths.push(path36);
+      paths.push(path37);
     }
     return paths;
   }
@@ -11249,18 +11352,13 @@ class ScalarCommand extends command("scalar", [ScalarScript], ({ public: target
 })) {
 }
 
-import path37 from "path";
-
-import path36 from "path";
-import latestVersion2 from "latest-version";
+import path38 from "path";
 
+import path37 from "path";
 class WorkspaceRunner extends runner("workspace") {
-  async#resolveAkanVersion(tag) {
-    return /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(tag) ? tag : await latestVersion2("akanjs", { version: tag });
-  }
-  async createWorkspace(repoName, appName, { dirname: dirname3 = ".", tag = "latest", init = true }) {
+  async createWorkspace(repoName, appName, { dirname: dirname3 = ".", init = true, akanVersion }) {
     const cwdPath = process.cwd();
-    const workspaceRoot = path36.join(cwdPath, dirname3, repoName);
+    const workspaceRoot = path37.join(cwdPath, dirname3, repoName);
     const workspace = WorkspaceExecutor.fromRoot({ workspaceRoot, repoName });
     const templateSpinner = workspace.spinning(`Creating workspace template files in ${dirname3}/${repoName}...`);
     await workspace.applyTemplate({
@@ -11270,7 +11368,6 @@ class WorkspaceRunner extends runner("workspace") {
     });
     templateSpinner.succeed(`Workspace files created in ${dirname3}/${repoName}`);
     const rootPackageJson = await workspace.getPackageJson();
-    const akanVersion = await this.#resolveAkanVersion(tag);
     const packageJson = {
       ...rootPackageJson,
       dependencies: {
@@ -11299,14 +11396,19 @@ class WorkspaceRunner extends runner("workspace") {
   }
 }
 
-class WorkspaceScript extends script("workspace", [WorkspaceRunner, ApplicationScript, LibraryScript]) {
-  async createWorkspace(repoName, appName, {
-    dirname: dirname3 = ".",
-    installLibs = false,
-    tag = "latest",
-    init = true
-  }) {
-    const workspace = await this.workspaceRunner.createWorkspace(repoName, appName, { dirname: dirname3, tag, init });
+class WorkspaceScript extends script("workspace", [
+  WorkspaceRunner,
+  ApplicationScript,
+  LibraryScript,
+  PackageScript
+]) {
+  async createWorkspace(repoName, appName, { dirname: dirname3 = ".", installLibs = false, init = true }) {
+    const akanVersion = await this.packageScript.version({ log: false });
+    const workspace = await this.workspaceRunner.createWorkspace(repoName, appName, {
+      dirname: dirname3,
+      init,
+      akanVersion
+    });
     if (installLibs) {
       await this.libraryScript.installLibrary(workspace, "util");
       await this.libraryScript.installLibrary(workspace, "shared");
@@ -11319,7 +11421,7 @@ class WorkspaceScript extends script("workspace", [WorkspaceRunner, ApplicationS
     } catch (_) {
       gitSpinner.fail("Git repository initialization failed. It's not fatal, you can commit manually");
     }
-    const workspacePath = path37.join(dirname3, repoName);
+    const workspacePath = path38.join(dirname3, repoName);
     Logger.rawLog(`
 \uD83C\uDF89 Welcome aboard! Workspace created in ${dirname3}/${repoName}`);
     Logger.rawLog(`\uD83D\uDE80 Run \`cd ${workspacePath} && akan start ${appName}\` to start the development server.`);
@@ -11374,15 +11476,12 @@ class WorkspaceCommand extends command("workspace", [WorkspaceScript], ({ public
         value: true
       }
     ]
-  }).option("tag", String, {
-    desc: "tag of the update",
-    default: "latest"
   }).option("init", Boolean, {
     desc: "Do you want to initialize the workspace? (Recommended)",
     default: true
-  }).exec(async function(workspaceName, app, dir, libs, tag, init) {
+  }).exec(async function(workspaceName, app, dir, libs, init) {
     const appName = app || "app";
-    await this.workspaceScript.createWorkspace(workspaceName.toLowerCase().replace(/ /g, "-"), appName.toLowerCase().replace(/ /g, "-"), { dirname: dir, installLibs: libs, tag, init });
+    await this.workspaceScript.createWorkspace(workspaceName.toLowerCase().replace(/ /g, "-"), appName.toLowerCase().replace(/ /g, "-"), { dirname: dir, installLibs: libs, init });
   }),
   lint: target({ desc: "Lint and fix code in a specific app/lib/pkg" }).with(Exec).option("fix", Boolean, { default: true }).with(Workspace).exec(async function(exec2, fix, workspace) {
     await this.workspaceScript.lint(exec2, workspace, { fix });