@akanjs/cli 0.0.58 → 0.0.59

package/index.js

@@ -283,7 +283,9 @@ var import_fs5 = __toESM(require("fs"), 1);
 var import_prompts2 = require("@langchain/core/prompts");
 var import_runnables = require("@langchain/core/runnables");
 var import_openai = require("@langchain/openai");
-var streamAi = async (question, callback) => {
+var streamAi = async (question, callback = (chunk) => {
+  process.stdout.write(chunk);
+}) => {
   const createStreamingModel = (apiKey = process.env.DEEPSEEK_API_KEY) => {
     if (!apiKey)
       throw new Error(`process.env.DEEPSEEK_API_KEY is not set`);
@@ -326,6 +328,21 @@ var import_dayjs3 = __toESM(require("dayjs"));
 var import_customParseFormat = __toESM(require("dayjs/plugin/customParseFormat"));
 import_dayjs3.default.extend(import_customParseFormat.default);
 
+// pkgs/@akanjs/common/randomPicks.ts
+var randomPicks = (arr, count = 1, allowDuplicate = false) => {
+  if (!allowDuplicate && arr.length <= count)
+    return arr;
+  const idxs = [];
+  let pickIdx;
+  for (let i = 0; i < count; i++) {
+    do {
+      pickIdx = Math.floor(Math.random() * arr.length);
+    } while (!allowDuplicate && idxs.includes(pickIdx));
+    idxs.push(pickIdx);
+  }
+  return idxs.map((idx) => arr[idx]);
+};
+
 // pkgs/@akanjs/common/pluralize.ts
 var import_pluralize = __toESM(require("pluralize"));
 
@@ -470,7 +487,7 @@ var Logger = class _Logger {
     if (typeof window === "undefined" && method !== "console" && global.process)
       global.process.stdout.write(msg);
     else
-      console.log(msg);
+      console.log(msg.trim());
   }
 };
 
@@ -1005,6 +1022,11 @@ var Executor = class {
     this.writeFile(filePath, JSON.stringify(content, null, 2));
     return this;
   }
+  getLocalFile(filePath) {
+    const filepath = import_path3.default.isAbsolute(filePath) ? filePath : filePath.replace(this.cwdPath, "");
+    const content = this.readFile(filepath);
+    return { filepath, content };
+  }
   readFile(filePath) {
     const readPath = import_path3.default.isAbsolute(filePath) ? filePath : `${this.cwdPath}/${filePath}`;
     return import_fs7.default.readFileSync(readPath, "utf8");
@@ -1043,7 +1065,7 @@ var Executor = class {
     targetPath,
     scanResult
   }, dict = {}) {
-    if (targetPath.endsWith(".js")) {
+    if (targetPath.endsWith(".js") || targetPath.endsWith(".jsx")) {
       const getContent = await import(templatePath);
       const content = getContent.default(scanResult ?? null, dict);
       const convertedTargetPath = Object.entries(dict).reduce(
@@ -1061,7 +1083,7 @@ var Executor = class {
         targetPath.slice(0, -9)
       );
       const convertedContent = Object.entries(dict).reduce(
-        (content2, [key, value]) => content2.replace(new RegExp(`<%= ${key} %>`, "g"), value),
+        (data, [key, value]) => data.replace(new RegExp(`<%= ${key} %>`, "g"), value),
         content
       );
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
@@ -1159,6 +1181,21 @@ var WorkspaceExecutor = class _WorkspaceExecutor extends Executor {
   async getPkgs() {
     return await this.#getDirHasFile(`${this.workspaceRoot}/pkgs`, "package.json");
   }
+  setTsPaths(type, name) {
+    const rootTsConfig = this.readJson("tsconfig.json");
+    if (type === "lib")
+      rootTsConfig.compilerOptions.paths[`@${name}`] = [`${type}s/${name}/index.ts`];
+    rootTsConfig.compilerOptions.paths[`@${name}/*`] = [`${type}s/${name}/*`];
+    this.writeJson("tsconfig.json", rootTsConfig);
+    return this;
+  }
+  async commit(message, { init = false, add = true } = {}) {
+    if (init)
+      await this.exec(`git init`);
+    if (add)
+      await this.exec(`git add .`);
+    await this.exec(`git commit -m "${message}"`);
+  }
   async #getDirHasFile(basePath2, targetFilename) {
     const AVOID_DIRS = ["node_modules", "dist", "public", "./next"];
     const getDirs = async (dirname, maxDepth = 3, results = [], prefix = "") => {
@@ -1181,6 +1218,14 @@ var WorkspaceExecutor = class _WorkspaceExecutor extends Executor {
     };
     return await getDirs(basePath2);
   }
+  async getScalarConstantFiles() {
+    const [appNames, libNames] = await this.getSyss();
+    const scalarConstantExampleFiles = [
+      ...(await Promise.all(appNames.map((appName) => AppExecutor.from(this, appName).getScalarConstantFiles()))).flat(),
+      ...(await Promise.all(libNames.map((libName) => LibExecutor.from(this, libName).getScalarConstantFiles()))).flat()
+    ];
+    return scalarConstantExampleFiles;
+  }
 };
 var SysExecutor = class extends Executor {
   workspace;
@@ -1324,6 +1369,11 @@ var SysExecutor = class extends Executor {
     this.writeJson(`akan.${this.type}.json`, scanResult);
     return scanResult;
   }
+  getLocalFile(filePath) {
+    const filepath = import_path3.default.isAbsolute(filePath) ? filePath : `${this.type}s/${this.name}/${filePath}`;
+    const content = this.workspace.readFile(filepath);
+    return { filepath, content };
+  }
   async getDatabaseModules() {
     const databaseModules = (await import_promises.default.readdir(`${this.cwdPath}/lib`)).filter((name) => !name.startsWith("_")).filter((name) => import_fs7.default.existsSync(`${this.cwdPath}/lib/${name}/${name}.constant.ts`));
     return databaseModules;
@@ -1336,6 +1386,22 @@ var SysExecutor = class extends Executor {
     const scalarModules = (await import_promises.default.readdir(`${this.cwdPath}/lib/__scalar`)).filter((name) => !name.startsWith("_")).filter((name) => import_fs7.default.existsSync(`${this.cwdPath}/lib/__scalar/${name}/${name}.constant.ts`));
     return scalarModules;
   }
+  async getScalarConstantFiles() {
+    const scalarModules = await this.getScalarModules();
+    return scalarModules.map(
+      (scalarModule) => this.getLocalFile(`lib/__scalar/${scalarModule}/${scalarModule}.constant.ts`)
+    );
+  }
+  async getScalarDictionaryFiles() {
+    const scalarModules = await this.getScalarModules();
+    return scalarModules.map(
+      (scalarModule) => this.getLocalFile(`lib/__scalar/${scalarModule}/${scalarModule}.dictionary.ts`)
+    );
+  }
+  setTsPaths() {
+    this.workspace.setTsPaths(this.type, this.name);
+    return this;
+  }
 };
 var AppExecutor = class _AppExecutor extends SysExecutor {
   constructor({ workspace, name }) {
@@ -1897,11 +1963,71 @@ var runCommands = async (...commands) => {
   await import_commander.program.parseAsync(process.argv);
 };
 
-// pkgs/@akanjs/devkit/src/installExternalLib.ts
-var installExternalLib = async (libName, workspace) => {
-  workspace.log(`Installing ${libName} library as git subtree...`);
-  await workspace.exec(`git remote add ${libName} git@github.com:akan-team/${libName}.git`);
-  await workspace.exec(`git subtree add --prefix=libs/${libName} ${libName} main`);
+// pkgs/@akanjs/devkit/src/aiEditor.ts
+var import_prompts4 = require("@inquirer/prompts");
+var import_messages = require("@langchain/core/messages");
+var import_openai2 = require("@langchain/openai");
+var MAX_ASK_TRY = 300;
+var AiSession = class _AiSession {
+  static #chat = new import_openai2.ChatOpenAI({
+    modelName: "deepseek-chat",
+    temperature: 0.7,
+    streaming: true,
+    // Enable streaming
+    configuration: { baseURL: "https://api.deepseek.com/v1", apiKey: process.env.DEEPSEEK_API_KEY }
+  });
+  messageHistory = [];
+  constructor(messageHistory = []) {
+    this.messageHistory = messageHistory;
+  }
+  async ask(question, {
+    onChunk = (chunk) => {
+      Logger.raw(chunk);
+    }
+  } = {}) {
+    try {
+      const humanMessage = new import_messages.HumanMessage(question);
+      this.messageHistory.push(humanMessage);
+      const stream = await _AiSession.#chat.stream(this.messageHistory);
+      let fullResponse = "";
+      for await (const chunk of stream) {
+        const content = chunk.content;
+        if (typeof content === "string") {
+          fullResponse += content;
+          onChunk(content);
+        }
+      }
+      this.messageHistory.push(new import_messages.AIMessage(fullResponse));
+      return { content: fullResponse, messageHistory: this.messageHistory };
+    } catch (error) {
+      throw new Error("Failed to stream response");
+    }
+  }
+  async edit(question, { onChunk, maxTry = MAX_ASK_TRY } = {}) {
+    for (let tryCount = 0; tryCount < maxTry; tryCount++) {
+      const response = await this.ask(question, { onChunk });
+      const isConfirmed = await (0, import_prompts4.select)({
+        message: "Do you want to edit the response?",
+        choices: [
+          { name: "\u2705 Yes, confirm and apply this result", value: true },
+          { name: "\u{1F504} No, I want to edit it more", value: false }
+        ]
+      });
+      if (isConfirmed)
+        return response.content;
+      question = await (0, import_prompts4.input)({ message: "What do you want to change?" });
+      tryCount++;
+    }
+    throw new Error("Failed to edit");
+  }
+  async editTypescript(question, options = {}) {
+    const content = await this.edit(question, options);
+    return this.#getTypescriptCode(content);
+  }
+  #getTypescriptCode(content) {
+    const code = /```typescript([\s\S]*?)```/.exec(content);
+    return code ? code[1] : content;
+  }
 };
 
 // pkgs/@akanjs/cli/src/library/library.runner.ts
@@ -1911,6 +2037,21 @@ var LibraryRunner = class {
     const scanResult = await lib.scan({ akanConfig });
     return scanResult;
   }
+  async installLibrary(workspace, libName) {
+    workspace.log(`Installing ${libName} library as git subtree...`);
+    await workspace.exec(`git subtree add --prefix=libs/${libName} git@github.com:akan-team/${libName}.git main`);
+    await workspace.cp(`libs/${libName}/env/env.server.example.ts`, `libs/${libName}/env/env.server.testing.ts`);
+    workspace.setTsPaths("lib", libName);
+    await workspace.commit(`Add ${libName} library`);
+  }
+  async pushLibrary(lib, branch) {
+    await lib.workspace.exec(`git subtree push --prefix=libs/${lib.name} ${lib.name} ${branch}`);
+    lib.logger.log(`${lib.name} library pushed to ${branch} branch`);
+  }
+  async pullLibrary(lib, branch) {
+    await lib.workspace.exec(`git subtree pull --prefix=libs/${lib.name} ${lib.name} ${branch}`);
+    lib.logger.log(`${lib.name} library pulled from ${branch} branch`);
+  }
 };
 
 // pkgs/@akanjs/cli/src/library/library.script.ts
@@ -1927,14 +2068,24 @@ var LibraryScript = class {
         await this.syncLibrary(LibExecutor.from(lib.workspace, libName), { recursive: false });
     }
   }
+  async installLibrary(workspace, libName) {
+    await this.#runner.installLibrary(workspace, libName);
+    workspace.log(`${libName} library installed`);
+  }
+  async pushLibrary(lib, branch) {
+    await this.#runner.pushLibrary(lib, branch);
+  }
+  async pullLibrary(lib, branch) {
+    await this.#runner.pullLibrary(lib, branch);
+  }
 };
 
 // pkgs/@akanjs/cli/src/application/application.runner.ts
-var import_prompts4 = require("@inquirer/prompts");
+var import_prompts5 = require("@inquirer/prompts");
 var import_output_parsers = require("@langchain/core/output_parsers");
-var import_prompts5 = require("@langchain/core/prompts");
+var import_prompts6 = require("@langchain/core/prompts");
 var import_runnables2 = require("@langchain/core/runnables");
-var import_openai2 = require("@langchain/openai");
+var import_openai3 = require("@langchain/openai");
 var import_plugin_react = __toESM(require("@vitejs/plugin-react"));
 var import_dotenv = __toESM(require("dotenv"));
 var esbuild = __toESM(require("esbuild"));
@@ -2475,6 +2626,409 @@ dictionaryStart
 
 dictionaryEnd
 
+`;
+var frameworkAbstract = `
+Intro
+- Build an all-stack application at once.
+- Write one line, deploy on web, app, server, database, and infra.
+- Akan is a framework with least code, highest performance for typescript-written applications.
+
+Key features
+- Integral interface: Akan serves an interface for building from schema, to service logic, api endpoint, state management, and component design.
+- Stable, Scalable, Safe built-in architecture: Fully type-safe, i18n, security, file management, text-search, automatic documentation, admin page, etc are all served with modular development.
+- application as a service: Akan deploys server, database, web, app at once through Akan cloud. Commit once, deploy and manage all.
+
+Procedure
+- add field on database and api at once, with fully typed
+- add backend api endpoint and frontend fetch function at once, with fully typed
+- write query interface and use everywhere!
+- No spaghetti state management anymore, build your global store with domain-driven state&actions.
+- No Spaghetti Components anymore, build your page with domain-driven components
+- write one page, use SSR on Next.js and build Android&iOS CSR app with beautiful page transitions!
+- built-in ai code generation, tell about business, the logic is generated.
+`;
+var scalarConstantDescription = `
+Purpose and Structure
+
+Scalar constant files define reusable data structures that can be embedded within other models. They represent complex field types
+that are not entities themselves but are used as components within larger data models. These are located in the __scalar directory
+within application or library modules.
+
+Key Characteristics
+
+- Defined with @Model.Scalar decorator (not @Model.Input, @Model.Object, etc.)
+- Do not have their own database collection
+- Cannot be queried independently
+- Used as embedded objects within other models
+- Often represent complex value objects or domain concepts
+
+Creating Scalar Constant Files
+
+File Organization
+
+1. Place scalar constants in the lib/__scalar/{scalarName}/ directory
+2. Name the file {scalarName}.constant.ts
+3. Register scalars in the _server.ts file in the __scalar directory
+
+Basic Structure
+
+import { Field, Model } from "@akanjs/constant";
+import { enumOf, Int, Dayjs } from "@akanjs/base"; // Import needed types
+
+// Optional: Define enums used by this scalar
+export const ScalarEnum = enumOf(["value1", "value2", "value3"] as const);
+export type ScalarEnum = enumOf<typeof ScalarEnum>;
+
+@Model.Scalar("ScalarName")  // Use the @Model.Scalar decorator
+export class ScalarName {
+  // Define properties with @Field.Prop decorator
+  @Field.Prop(() => String)
+  stringProperty: string;
+
+  @Field.Prop(() => Int, { min: 0 })
+  numericProperty: number;
+
+  @Field.Prop(() => Boolean, { default: false })
+  booleanProperty: boolean;
+
+  @Field.Prop(() => Date)
+  dateProperty: Dayjs;
+
+  @Field.Prop(() => String, { enum: ScalarEnum })
+  enumProperty: ScalarEnum;
+
+  @Field.Prop(() => String, { nullable: true })
+  optionalProperty: string | null;
+}
+
+
+Common Types of Scalar Objects
+
+Based on the analyzed codebase, here are common patterns for scalar objects:
+
+1. Value Objects
+
+Simple structures that group related properties:
+
+@Model.Scalar("Address")
+export class Address {
+  @Field.Prop(() => String)
+  street: string;
+
+  @Field.Prop(() => String)
+  city: string;
+
+  @Field.Prop(() => String)
+  zipCode: string;
+
+  @Field.Prop(() => String)
+  country: string;
+}
+
+2. Configuration Objects
+
+Objects holding configuration or settings:
+
+@Model.Scalar("NotificationSettings")
+export class NotificationSettings {
+  @Field.Prop(() => Boolean, { default: true })
+  emailEnabled: boolean;
+
+  @Field.Prop(() => Boolean, { default: true })
+  pushEnabled: boolean;
+
+  @Field.Prop(() => Boolean, { default: false })
+  smsEnabled: boolean;
+}
+
+3. Metadata Objects
+
+Objects providing metadata about other entities:
+
+@Model.Scalar("FileMeta")
+export class FileMeta {
+  @Field.Prop(() => Date)
+  lastModifiedAt: Dayjs;
+
+  @Field.Prop(() => Int)
+  size: number;
+
+  @Field.Prop(() => String, { nullable: true })
+  mimeType: string | null;
+}
+
+4. Complex Value Type Objects
+
+Objects representing domain-specific complex values:
+
+@Model.Scalar("GeoLocation")
+export class GeoLocation {
+  @Field.Prop(() => Float)
+  latitude: number;
+
+  @Field.Prop(() => Float)
+  longitude: number;
+
+  @Field.Prop(() => Float, { nullable: true })
+  altitude: number | null;
+}
+
+Best Practices
+
+1. Keep it Simple: Scalar objects should be focused on a single concept
+2. No External References: Avoid referencing entities directly from scalar objects
+3. Validation Rules: Include validation rules in field definitions
+4. Default Values: Provide sensible defaults where appropriate
+5. Documentation: Document the purpose and usage of each scalar type
+6. Reusability: Design scalar objects to be reusable across different models
+7. Immutability: Treat scalar objects as immutable value objects
+8. Naming Convention: Use descriptive names that reflect the domain concept
+
+Using Scalar Types in Models
+
+After defining scalar objects, you can use them in your entity models:
+
+import { Field, Model } from "@akanjs/constant";
+import { FileMeta } from "../__scalar/fileMeta/fileMeta.constant";
+import { ExternalLink } from "../__scalar/externalLink/externalLink.constant";
+
+@Model.Input("ProfileInput")
+export class ProfileInput {
+  @Field.Prop(() => String)
+  name: string;
+
+  @Field.Prop(() => FileMeta, { nullable: true })
+  avatar: FileMeta | null;
+
+  @Field.Prop(() => [ExternalLink])
+  socialLinks: ExternalLink[];
+}
+
+Key Differences from Regular Models
+
+This structured approach to scalar objects helps maintain clean, modular, and reusable code across your application, while keeping
+the domain concepts well-organized and type-safe.
+`;
+var howToSetEnumInModelConstant = `
+Declaring Enumerations in Constant Files
+
+Enumerations in the constant.ts files are declared using the enumOf utility function from the @akanjs/base package. This creates
+type-safe enumeration values with strong typing support.
+
+Basic Enum Declaration
+
+import { enumOf } from "@akanjs/base";
+
+// Define the enum values as a const array
+// Export the type derived from the enum
+export const UserStatus = enumOf(["active", "inactive", "pending"] as const);
+export type UserStatus = enumOf<typeof UserStatus>;
+
+Key Features
+
+1. Type Safety: The as const assertion ensures values are treated as literal types
+2. Value Access: Enum values can be accessed via UserStatus.values
+3. Auto-completion: TypeScript provides auto-completion for enum values
+4. Validation: Prevents assigning invalid values to fields using this enum
+
+Using Enums with Field Decorators
+
+@Field.Prop(() => String, { enum: UserStatus, default: "active" })
+status: UserStatus;
+
+// For array of enum values
+@Field.Prop(() => [String], { enum: UserRole, default: ["user"] })
+roles: UserRole[];
+`;
+var howToSetFieldInModelConstant = `
+# @Field Decorator Documentation
+
+The \`@Field\` decorator is used in the Akamir framework to define properties for model classes. This documentation focuses on the usage of \`@Field.Prop()\` and its available options.
+
+## Basic Usage
+
+The \`@Field.Prop()\` decorator is used to define properties in model classes with specific types and options:
+
+\`\`\`typescript
+@Field.Prop(() => Type, { ...options })
+propertyName: PropertyType;
+\`\`\`
+
+Where:
+- \`Type\` is the GraphQL type for the property (e.g., \`String\`, \`Int\`, \`ID\`, etc.)
+- \`options\` is an optional object containing configuration parameters
+- \`PropertyType\` is the TypeScript type of the property
+
+## Available Options
+
+The following options can be provided to \`@Field.Prop()\`:
+
+### Basic Options
+
+| Option      | Type                                          | Description                                        | Example                                        |
+|-------------|-----------------------------------------------|----------------------------------------------------|------------------------------------------------|
+| \`nullable\`  | \`boolean\`                                     | Specifies if the field can be null                 | \`{ nullable: true }\`                           |
+| \`default\`   | \`string \\| number \\| boolean \\| object \\| null \\| Enum\` | Default value for the field                       | \`{ default: "active" }\` or \`{ default: 0 }\`    |
+| \`enum\`      | \`Enum<string \\| number>\`                      | Restricts field values to predefined enum values   | \`{ enum: ProductStatus }\`                      |
+| \`type\`      | \`"email" \\| "password" \\| "url"\`              | Special field type for validation                   | \`{ type: "email" }\`                            |
+
+### Reference Options
+
+| Option      | Type                          | Description                                        | Example                                        |
+|-------------|-------------------------------|----------------------------------------------------|------------------------------------------------|
+| \`ref\`       | \`string\`                      | Reference to another model (by model name)         | \`{ ref: "product" }\`                           |
+| \`refPath\`   | \`string\`                      | Path to field containing the model name            | \`{ refPath: "modelType" }\`                     |
+| \`refType\`   | \`"child" \\| "parent" \\| "relation"\` | Type of relationship between models            | \`{ refType: "child" }\`                         |
+
+### Validation Options
+
+| Option      | Type                          | Description                                        | Example                                        |
+|-------------|-------------------------------|----------------------------------------------------|------------------------------------------------|
+| \`min\`       | \`number\`                      | Minimum value for number fields                    | \`{ min: 0 }\`                                   |
+| \`max\`       | \`number\`                      | Maximum value for number fields                    | \`{ max: 100 }\`                                 |
+| \`minlength\` | \`number\`                      | Minimum length for string fields                   | \`{ minlength: 3 }\`                             |
+| \`maxlength\` | \`number\`                      | Maximum length for string fields                   | \`{ maxlength: 50 }\`                            |
+| \`validate\`  | \`(value: any, model: any) => boolean\` | Custom validation function                | \`{ validate: isPhoneNumber }\`                  |
+
+### Field Behavior Options
+
+| Option      | Type                                          | Description                                        | Example                                        |
+|-------------|-----------------------------------------------|----------------------------------------------------|------------------------------------------------|
+| \`fieldType\` | \`"property" \\| "hidden" \\| "resolve"\`         | Determines how field is used in GraphQL schema     | \`{ fieldType: "hidden" }\`                      |
+| \`immutable\` | \`boolean\`                                     | Makes field immutable after creation               | \`{ immutable: true }\`                          |
+| \`select\`    | \`boolean\`                                     | Controls if field is included in query results     | \`{ select: false }\`                            |
+| \`query\`     | \`QueryOf<any> \\| (() => QueryOf<any>)\`        | MongoDB query for this field                       | \`{ query: {} }\`                                |
+| \`accumulate\`| \`AccumulatorOperator\`                         | MongoDB accumulator operator for aggregation       | \`{ accumulate: { $sum: 1 } }\`                  |
+| \`text\`      | \`"search" \\| "filter"\`                        | Enables text search or filter on this field        | \`{ text: "search" }\`                           |
+
+### Other Options
+
+| Option      | Type                                          | Description                                        | Example                                        |
+|-------------|-----------------------------------------------|----------------------------------------------------|------------------------------------------------|
+| \`of\`        | \`GqlScalar\`                                   | Used for Map type fields to specify value type     | \`{ of: String }\`                               |
+| \`example\`   | \`string \\| number \\| boolean \\| Dayjs \\| Array\` | Example value for documentation/playground       | \`{ example: "example@email.com" }\`             |
+
+## Examples
+
+### Basic Property Definition
+
+\`\`\`typescript
+@Field.Prop(() => String)
+name: string;
+\`\`\`
+
+### Nullable Field with Default Value
+
+\`\`\`typescript
+@Field.Prop(() => String, { nullable: true, default: "Default Description" })
+description: string | null;
+\`\`\`
+
+### Enum-Constrained Field
+
+\`\`\`typescript
+@Field.Prop(() => String, { enum: ProductStatus, default: "active" })
+status: ProductStatus;
+\`\`\`
+
+### Number Field with Minimum Value
+
+\`\`\`typescript
+@Field.Prop(() => Int, { min: 0, default: 0 })
+totalProduct: number;
+\`\`\`
+
+### Field with Custom Validation
+
+\`\`\`typescript
+@Field.Prop(() => String, { validate: isPhoneNumber })
+phone: string;
+\`\`\`
+
+### Field with Special Type
+
+\`\`\`typescript
+@Field.Prop(() => String, { type: "email" })
+email: string;
+\`\`\`
+
+### Relationship Field
+
+\`\`\`typescript
+@Field.Prop(() => LightBizLicense, { nullable: true })
+bizLicense: LightBizLicense | null;
+\`\`\`
+
+### Aggregation Field
+
+\`\`\`typescript
+@Field.Prop(() => Int, { default: 0, accumulate: { $sum: 1 } })
+count: number;
+\`\`\`
+
+## Usage Patterns
+
+The \`@Field.Prop()\` decorator is commonly used in different model types:
+
+- **Input Models** (\`@Model.Input\`): Used for creating/updating objects
+- **Object Models** (\`@Model.Object\`): Base model representation
+- **Light Models** (\`@Model.Light\`): Light version with selected fields
+- **Full Models** (\`@Model.Full\`): Complete model representation
+- **Insight Models** (\`@Model.Insight\`): Used for analytics/statistics
+- **Summary Models** (\`@Model.Summary\`): Used for data summaries
+
+## Notes
+
+- The options allow for flexible field definition with both GraphQL and MongoDB integrations
+- Validation options help ensure data integrity at the model level
+- Reference options enable building relationships between different models
+- Aggregation options support analytics use cases
+`;
+var requestScalarConstant = ({
+  sysName,
+  modelName,
+  modelDesc,
+  modelSchemaDesign,
+  boilerplate,
+  otherConstants
+}) => `
+\uB108\uB294 Akan.js\uB77C\uB294 \uC0AC\uB0B4 \uD504\uB808\uC784\uC6CC\uD06C\uB85C Typescript \uAE30\uBC18 \uD504\uB85C\uADF8\uB7A8\uC744 \uC791\uC131\uD558\uB294 \uC2DC\uB2C8\uC5B4 \uAC1C\uBC1C\uC790\uC57C.
+\uB2E4\uC74C\uC758 \uBC30\uACBD \uC815\uBCF4\uB97C \uBC14\uD0D5\uC73C\uB85C ${modelName}.constant.ts \uD30C\uC77C\uC744 \uC791\uC131\uD574\uC918.
+
+1. Akan.js \uD504\uB808\uC784\uC6CC\uD06C\uC5D0 \uB300\uD55C \uAC1C\uC694
+${frameworkAbstract}
+
+2. <model>.constant.ts \uD30C\uC77C\uC5D0 \uB300\uD55C \uAC1C\uC694
+${scalarConstantDescription}
+
+3. <model.constant.ts \uD30C\uC77C\uC758 Enum \uC791\uC131\uBC95
+${howToSetEnumInModelConstant}
+
+4. <model.constant.ts \uD30C\uC77C\uC758 Field \uC791\uC131\uBC95
+${howToSetFieldInModelConstant}
+
+5. \uD604\uC7AC \uD504\uB85C\uC81D\uD2B8 \uB0B4 \uB2E4\uB978 constant.ts \uD30C\uC77C\uB4E4\uC5D0 \uB300\uD55C \uC608\uC2DC
+${otherConstants.map(
+  (constant) => `
+Example file: ${constant.filepath}
+\`\`\`
+${constant.content}
+\`\`\`
+`
+).join("\n")}
+
+
+\uC704 \uB0B4\uC6A9\uB4E4\uC744 \uBC14\uD0D5\uC73C\uB85C \uD30C\uC2F1\uD558\uAE30 \uC27D\uAC8C \uC544\uB798\uC5D0 \uBCF4\uC77C\uB7EC\uD50C\uB808\uC774\uD2B8\uC5D0 \uB9DE\uAC8C \uC815\uB9AC\uD574\uC11C \uC918
+
+Application name: ${sysName}
+Model name: ${modelName}
+Model description: ${modelDesc}
+Model schema design: ${modelSchemaDesign}
+
+Target filename: ${modelName}.constant.ts
+\`\`\`
+${boilerplate}
+\`\`\`
 `;
 
 // pkgs/@akanjs/cli/src/application/application.prompt.ts
@@ -2511,6 +3065,20 @@ page.tsx_end
 
 // pkgs/@akanjs/cli/src/application/application.runner.ts
 var ApplicationRunner = class {
+  async createApplication(appName, workspace) {
+    await workspace.applyTemplate({
+      basePath: `apps/${appName}`,
+      template: "app",
+      dict: {
+        appName,
+        AppName: capitalize(appName),
+        companyName: workspace.repoName,
+        CompanyName: capitalize(workspace.repoName),
+        serveDomain: "localhost"
+      }
+    });
+    workspace.setTsPaths("app", appName);
+  }
   async scanSync(app) {
     const akanConfig = await getAppConfig(app.cwdPath, { ...getBaseDevEnv(), appName: app.name, command: "serve" });
     const scanResult = await app.scan({ akanConfig });
@@ -2786,11 +3354,11 @@ var ApplicationRunner = class {
   async configureApp(app) {
     const capacitorApp = new CapacitorApp(app);
     await capacitorApp.init();
-    if (await (0, import_prompts4.confirm)({ message: "want to add camera permission?" }))
+    if (await (0, import_prompts5.confirm)({ message: "want to add camera permission?" }))
       await capacitorApp.addCamera();
-    if (await (0, import_prompts4.confirm)({ message: "want to add contact permission?" }))
+    if (await (0, import_prompts5.confirm)({ message: "want to add contact permission?" }))
       await capacitorApp.addContact();
-    if (await (0, import_prompts4.confirm)({ message: "want to add location permission?" }))
+    if (await (0, import_prompts5.confirm)({ message: "want to add location permission?" }))
       await capacitorApp.addLocation();
     await capacitorApp.save();
   }
@@ -2939,11 +3507,11 @@ var ApplicationRunner = class {
     const openAIApiKey = process.env.OPENAI_API_KEY;
     if (!openAIApiKey)
       throw new Error("OPENAI_API_KEY is not set");
-    const chatModel = new import_openai2.ChatOpenAI({ modelName: "gpt-4o", openAIApiKey });
-    const projectName = await (0, import_prompts4.input)({ message: "please enter project name." });
-    const projectDesc = await (0, import_prompts4.input)({ message: "please enter project description. (40 ~ 60 characters)" });
+    const chatModel = new import_openai3.ChatOpenAI({ modelName: "gpt-4o", openAIApiKey });
+    const projectName = await (0, import_prompts5.input)({ message: "please enter project name." });
+    const projectDesc = await (0, import_prompts5.input)({ message: "please enter project description. (40 ~ 60 characters)" });
     const spinner = (0, import_ora2.default)("Gerating project files...");
-    const mainPrompt = import_prompts5.PromptTemplate.fromTemplate(requestApplication());
+    const mainPrompt = import_prompts6.PromptTemplate.fromTemplate(requestApplication());
     const chain = import_runnables2.RunnableSequence.from([mainPrompt, chatModel, new import_output_parsers.StringOutputParser()]);
     const resultOne = await chain.invoke({ projectName, projectDesc });
     spinner.succeed("Loading complete!");
@@ -2965,6 +3533,9 @@ var ApplicationRunner = class {
 var ApplicationScript = class {
   #runner = new ApplicationRunner();
   libraryScript = new LibraryScript();
+  async createApplication(appName, workspace) {
+    await this.#runner.createApplication(appName, workspace);
+  }
   async scanApplication(app) {
     const scanResult = await this.#runner.scanSync(app);
     app.logger.rawLog(JSON.stringify(scanResult, null, 2));
@@ -3054,6 +3625,7 @@ var ApplicationScript = class {
 var ApplicationCommand = class {
   applicationScript = new ApplicationScript();
   async createApplication(name, workspace) {
+    await this.applicationScript.createApplication(name, workspace);
   }
   async removeApplication(app, workspace) {
   }
@@ -3233,13 +3805,12 @@ ApplicationCommand = __decorateClass([
 var esbuild2 = __toESM(require("esbuild"));
 var import_esbuild_plugin_d = require("esbuild-plugin-d.ts");
 var import_promises3 = __toESM(require("fs/promises"));
-var import_lodash = require("lodash");
 var PackageRunner = class {
   async createPackage(workspace, pkgName) {
     await workspace.applyTemplate({
       basePath: `pkgs/${pkgName}`,
       template: "pkgRoot",
-      dict: { pkgName, PkgName: (0, import_lodash.capitalize)(pkgName) }
+      dict: { pkgName, PkgName: capitalize(pkgName) }
     });
   }
   async scanSync(pkg) {
@@ -3277,7 +3848,7 @@ var PackageRunner = class {
       });
       await esbuild2.build({
         write: true,
-        entryPoints: [`${pkg.cwdPath}/src/templates/**/*.ts`, `${pkg.cwdPath}/src/templates/**/*.tsx`],
+        entryPoints: [`${pkg.cwdPath}/src/templates/**/*.ts`],
         packages: "external",
         outdir: `${distPkg.cwdPath}/src/templates`,
         outbase: `${pkg.cwdPath}/src/templates`,
@@ -3285,16 +3856,36 @@ var PackageRunner = class {
         platform: "node",
         footer: { js: "module.exports = module.exports.default;" }
       });
+      await esbuild2.build({
+        write: true,
+        entryPoints: [`${pkg.cwdPath}/src/templates/**/*.tsx`],
+        packages: "external",
+        outdir: `${distPkg.cwdPath}/src/templates`,
+        outbase: `${pkg.cwdPath}/src/templates`,
+        format: "cjs",
+        platform: "node",
+        footer: { js: "module.exports = module.exports.default;" },
+        outExtension: { ".js": ".jsx" }
+      });
       await pkg.workspace.exec(
         `rsync -aq --exclude="*.ts" --exclude="*.tsx" ${pkg.cwdPath}/src/templates/ ${distPkg.cwdPath}/src/templates/`
       );
     } else {
+      const platform = [
+        "@akanjs/devkit",
+        "@akanjs/document",
+        "@akanjs/lint",
+        "@akanjs/nest",
+        "@akanjs/server",
+        "@akanjs/service"
+      ].includes(pkg.name) ? "node" : ["@akanjs/client", "@akanjs/next", "@akanjs/store", "@akanjs/ui"].includes(pkg.name) ? "browser" : "neutral";
       buildResult = await esbuild2.build({
         write: false,
         entryPoints: [`${pkg.cwdPath}/**/*.ts`, `${pkg.cwdPath}/**/*.tsx`],
         bundle: false,
         packages: "external",
         splitting: false,
+        platform,
         format: "cjs",
         outdir: distPkg.cwdPath,
         outExtension: { ".js": pkgJson.type === "module" ? ".cjs" : ".js" },
@@ -3307,6 +3898,7 @@ var PackageRunner = class {
         bundle: false,
         packages: "external",
         splitting: false,
+        platform,
         format: "esm",
         outdir: distPkg.cwdPath,
         outExtension: { ".js": pkgJson.type === "module" ? ".js" : ".mjs" },
@@ -3352,7 +3944,7 @@ var PackageScript = class {
 };
 
 // pkgs/@akanjs/cli/src/cloud/cloud.runner.ts
-var import_prompts6 = require("@inquirer/prompts");
+var import_prompts7 = require("@inquirer/prompts");
 var import_chalk = __toESM(require("chalk"));
 var import_latest_version = __toESM(require("latest-version"));
 var import_open = __toESM(require("open"));
@@ -3455,7 +4047,7 @@ ${import_chalk.default.green("\u27A4")} Authentication Required`));
       };
       workspace.writeJson(`dist/pkgs/${library}/package.json`, newDistPackageJson);
     }
-    const isDeployConfirmed = await (0, import_prompts6.confirm)({
+    const isDeployConfirmed = await (0, import_prompts7.confirm)({
       message: "Are you sure you want to deploy the libraries?"
     });
     if (!isDeployConfirmed) {
@@ -3531,7 +4123,14 @@ var LibraryCommand = class {
   }
   async buildLibrary(lib) {
   }
-  async pushLibrary(lib) {
+  async installLibrary(name, workspace) {
+    await this.libraryScript.installLibrary(workspace, name);
+  }
+  async pushLibrary(lib, branch) {
+    await this.libraryScript.pushLibrary(lib, branch);
+  }
+  async pullLibrary(lib, branch) {
+    await this.libraryScript.pullLibrary(lib, branch);
   }
 };
 __decorateClass([
@@ -3552,29 +4151,39 @@ __decorateClass([
   Target.Public(),
   __decorateParam(0, Lib())
 ], LibraryCommand.prototype, "buildLibrary", 1);
+__decorateClass([
+  Target.Public(),
+  __decorateParam(0, Option("name", { desc: "name of library" })),
+  __decorateParam(1, Workspace())
+], LibraryCommand.prototype, "installLibrary", 1);
 __decorateClass([
   Target.Public({ devOnly: true }),
-  __decorateParam(0, Lib())
+  __decorateParam(0, Lib()),
+  __decorateParam(1, Option("branch", { desc: "branch to push", default: "main" }))
 ], LibraryCommand.prototype, "pushLibrary", 1);
+__decorateClass([
+  Target.Public(),
+  __decorateParam(0, Lib()),
+  __decorateParam(1, Option("branch", { desc: "branch to pull", default: "main" }))
+], LibraryCommand.prototype, "pullLibrary", 1);
 LibraryCommand = __decorateClass([
   Commands()
 ], LibraryCommand);
 
 // pkgs/@akanjs/cli/src/module/module.runner.ts
 var import_output_parsers2 = require("@langchain/core/output_parsers");
-var import_prompts7 = require("@langchain/core/prompts");
+var import_prompts8 = require("@langchain/core/prompts");
 var import_runnables3 = require("@langchain/core/runnables");
-var import_openai3 = require("@langchain/openai");
+var import_openai4 = require("@langchain/openai");
 var import_fs11 = __toESM(require("fs"));
-var import_lodash2 = require("lodash");
 var ModuleRunner = class {
   async createModule(workspace, moduleName) {
     const openAIApiKey = process.env.OPENAI_API_KEY;
     if (!openAIApiKey)
       throw new Error("OPENAI_API_KEY is not set");
-    const chatModel = new import_openai3.ChatOpenAI({ modelName: "gpt-4o", openAIApiKey });
+    const chatModel = new import_openai4.ChatOpenAI({ modelName: "gpt-4o", openAIApiKey });
     const projectConfig = JSON.parse(import_fs11.default.readFileSync(`rootPath/projectConfig.json`, "utf-8"));
-    const mainPrompt = import_prompts7.PromptTemplate.fromTemplate(requestModule());
+    const mainPrompt = import_prompts8.PromptTemplate.fromTemplate(requestModule());
     const chain = import_runnables3.RunnableSequence.from([mainPrompt, chatModel, new import_output_parsers2.StringOutputParser()]);
     const resultOne = await chain.invoke({
       projectName: projectConfig.en.projectName,
@@ -3593,7 +4202,7 @@ var ModuleRunner = class {
       basePath: "./lib/__scalar",
       template: "__scalar",
       scanResult,
-      dict: { model: name, Model: (0, import_lodash2.capitalize)(name) }
+      dict: { model: name, Model: capitalize(name) }
     });
     await sys2.scan({ akanConfig });
     return {
@@ -3607,7 +4216,7 @@ var ModuleRunner = class {
   async createUnit(sys2, modelName) {
     const modelFileData = getModelFileData(sys2.cwdPath, modelName);
     const { paths } = getRelatedCnsts(modelFileData.constantFilePath);
-    const names = { model: modelName, Model: (0, import_lodash2.capitalize)(modelName), LightModel: `Light${(0, import_lodash2.capitalize)(modelName)}` };
+    const names = { model: modelName, Model: capitalize(modelName), LightModel: `Light${capitalize(modelName)}` };
     const prompt = `\uB108\uB294 React, Typescript, TailwindCSS\uB97C \uAE30\uBC18\uC73C\uB85C \uCF54\uB529\uD558\uB294 \uD504\uB860\uD2B8\uC5D4\uB4DC \uAC1C\uBC1C\uC790\uC57C.
 ${names.Model}\uC774\uB77C\uB294 \uB3C4\uBA54\uC778\uC5D0 \uB300\uD574\uC11C ${names.LightModel} \uC2A4\uD0A4\uB9C8\uB97C \uB300\uC0C1\uC73C\uB85C react component\uB97C \uB514\uC790\uC778\uD558\uB824\uACE0 \uD574. \uC544\uB798\uB294 \uD604\uC7AC \uBCF4\uC77C\uB7EC\uD50C\uB808\uC774\uD2B8 \uD615\uD0DC\uC758 \uCEF4\uD3EC\uB10C\uD2B8\uC57C.
 
@@ -3653,7 +4262,7 @@ ${names.Model}.Unit.Card\uC758 \uB9AC\uC561\uD2B8 \uCEF4\uD3EC\uB10C\uD2B8\uB97C
   async createView(sys2, modelName) {
     const modelFileData = getModelFileData(sys2.cwdPath, modelName);
     const { paths } = getRelatedCnsts(modelFileData.constantFilePath);
-    const names = { model: modelName, Model: (0, import_lodash2.capitalize)(modelName), LightModel: `Light${(0, import_lodash2.capitalize)(modelName)}` };
+    const names = { model: modelName, Model: capitalize(modelName), LightModel: `Light${capitalize(modelName)}` };
     const prompt = `\uB108\uB294 React, Typescript, TailwindCSS\uB97C \uAE30\uBC18\uC73C\uB85C \uCF54\uB529\uD558\uB294 \uD504\uB860\uD2B8\uC5D4\uB4DC \uAC1C\uBC1C\uC790\uC57C.
   ${names.Model}\uC774\uB77C\uB294 \uB3C4\uBA54\uC778\uC5D0 \uB300\uD574\uC11C ${names.Model} \uC2A4\uD0A4\uB9C8\uB97C \uB300\uC0C1\uC73C\uB85C react component\uB97C \uB514\uC790\uC778\uD558\uB824\uACE0 \uD574. \uC544\uB798\uB294 \uD604\uC7AC \uBCF4\uC77C\uB7EC\uD50C\uB808\uC774\uD2B8 \uD615\uD0DC\uC758 \uCEF4\uD3EC\uB10C\uD2B8\uC57C.
   
@@ -3706,35 +4315,21 @@ var ModuleScript = class {
   }
   async removeModule(workspace, name) {
   }
-  async createScalar(sys2, name) {
-    const [appNames, libNames] = await sys2.workspace.getSyss();
-    const scalarConstantExampleFiles = [
-      ...(await Promise.all(
-        appNames.map(async (appName) => {
-          const app = AppExecutor.from(sys2.workspace, appName);
-          const scalarModules = await app.getScalarModules();
-          return await Promise.all(
-            scalarModules.map((scalarModule) => ({
-              path: `${appName}/${scalarModule}/${scalarModule}.constant.ts`,
-              content: app.readFile(`lib/__scalar/${scalarModule}/${scalarModule}.constant.ts`)
-            }))
-          );
-        })
-      )).flat(),
-      ...(await Promise.all(
-        libNames.map(async (libName) => {
-          const lib = LibExecutor.from(sys2.workspace, libName);
-          const scalarModules = await lib.getScalarModules();
-          return await Promise.all(
-            scalarModules.map((scalarModule) => ({
-              path: `${libName}/${scalarModule}/${scalarModule}.constant.ts`,
-              content: lib.readFile(`lib/__scalar/${scalarModule}/${scalarModule}.constant.ts`)
-            }))
-          );
-        })
-      )).flat()
-    ];
+  async createScalar(sys2, name, description, schemaDescription) {
+    const scalarConstantExampleFiles = await sys2.workspace.getScalarConstantFiles();
     const { constant, dictionary } = await this.#runner.createScalarTemplate(sys2, name);
+    const session = new AiSession();
+    const content = await session.editTypescript(
+      requestScalarConstant({
+        sysName: sys2.name,
+        modelName: name,
+        modelDesc: description,
+        modelSchemaDesign: schemaDescription,
+        boilerplate: constant.content,
+        otherConstants: randomPicks(scalarConstantExampleFiles, Math.min(10, scalarConstantExampleFiles.length))
+      })
+    );
+    sys2.writeFile(`lib/__scalar/${name}/${name}.constant.ts`, content);
   }
   async createService(workspace, name) {
   }
@@ -3759,8 +4354,8 @@ var ModuleCommand = class {
   }
   async scanModule(name, workspace) {
   }
-  async createScalar(sys2, name, workspace) {
-    await this.moduleScript.createScalar(sys2, name);
+  async createScalar(sys2, name, description, schemaDescription, workspace) {
+    await this.moduleScript.createScalar(sys2, name, description, schemaDescription);
   }
   async createService(name, workspace) {
   }
@@ -3790,7 +4385,9 @@ __decorateClass([
   Target.Public(),
   __decorateParam(0, Sys()),
   __decorateParam(1, Option("name", { desc: "name of scalar module" })),
-  __decorateParam(2, Workspace())
+  __decorateParam(2, Option("description", { desc: "description of scalar module" })),
+  __decorateParam(3, Option("schemaDescription", { desc: "schema description of scalar module" })),
+  __decorateParam(4, Workspace())
 ], ModuleCommand.prototype, "createScalar", 1);
 __decorateClass([
   Target.Public(),
@@ -3929,16 +4526,13 @@ var WorkspaceRunner = class {
     };
     workspace.writeJson(`infra/master/mongo-connections.json`, mongoConnectionList);
   }
-  async installLibrary(workspace, libName) {
-    workspace.log(`Installing ${libName} library as git subtree...`);
-    await workspace.exec(`git remote add ${libName} git@github.com:akan-team/${libName}.git`);
-    await workspace.exec(`git subtree add --prefix=libs/${libName} ${libName} main`);
-  }
 };
 
 // pkgs/@akanjs/cli/src/workspace/workspace.script.ts
 var WorkspaceScript = class {
   #runner = new WorkspaceRunner();
+  applicationScript = new ApplicationScript();
+  libraryScript = new LibraryScript();
   async createWorkspace(repoName, appName, dirname = ".") {
     const cwdPath = process.cwd();
     const workspaceRoot = import_path5.default.join(cwdPath, dirname, repoName);
@@ -3975,34 +4569,33 @@ var WorkspaceScript = class {
     await workspace.applyTemplate({
       basePath: ".",
       template: "workspaceRoot",
-      dict: { repoName, RepoName: capitalize(repoName) }
+      dict: {
+        repoName,
+        RepoName: capitalize(repoName),
+        appName,
+        AppName: capitalize(appName),
+        serveDomain: "localhost"
+      }
     });
     workspace.log("Installing dependencies...");
     await workspace.spawn("pnpm", ["i"]);
     workspace.log("Initializing git repository and commit...");
-    await workspace.exec(`git init`);
-    await workspace.exec(`git add .`);
-    await workspace.exec(`git commit -m "Initial commit"`);
-    await installExternalLib("util", workspace);
-    await installExternalLib("shared", workspace);
+    await workspace.commit("Initial commit", { init: true });
+    await this.libraryScript.installLibrary(workspace, "util");
+    await this.libraryScript.installLibrary(workspace, "shared");
+    await this.applicationScript.createApplication(appName, workspace);
   }
   async generateMongo(workspace) {
     await this.#runner.generateMongo(workspace);
     workspace.log(`Mongo connections generated in infra/master/mongo-connections.json`);
   }
-  async installLibrary(workspace, libName) {
-    await this.#runner.installLibrary(workspace, libName);
-    workspace.log(`${libName} library installed`);
-  }
 };
 
 // pkgs/@akanjs/cli/src/workspace/workspace.command.ts
 var WorkspaceCommand = class {
   workspaceScript = new WorkspaceScript();
-  async createWorkspace(name, dir, app) {
-  }
-  async installLibrary(name, workspace) {
-    await this.workspaceScript.installLibrary(workspace, name);
+  async createWorkspace(name, app, dir) {
+    await this.workspaceScript.createWorkspace(name, app, dir);
   }
   async generateMongo(workspace) {
     await this.workspaceScript.generateMongo(workspace);
@@ -4011,14 +4604,9 @@ var WorkspaceCommand = class {
 __decorateClass([
   Target.Public(),
   __decorateParam(0, Option("name", { desc: "name of workspace" })),
-  __decorateParam(1, Option("dir", { desc: "directory of workspace" })),
-  __decorateParam(2, Option("app", { desc: "application name" }))
+  __decorateParam(1, Option("app", { desc: "application name" })),
+  __decorateParam(2, Option("dir", { desc: "directory of workspace", default: process.env.USE_AKANJS_PKGS === "true" ? "local" : "." }))
 ], WorkspaceCommand.prototype, "createWorkspace", 1);
-__decorateClass([
-  Target.Public(),
-  __decorateParam(0, Option("name", { desc: "name of library" })),
-  __decorateParam(1, Workspace())
-], WorkspaceCommand.prototype, "installLibrary", 1);
 __decorateClass([
   Target.Public(),
   __decorateParam(0, Workspace())