akanjs 0.0.1 → 2.0.0-beta.0

package/cli/module/module.script.ts

@@ -0,0 +1,161 @@
+import { capitalize, randomPicks } from "akanjs/common";
+import {
+  AiSession,
+  type App,
+  FileSys,
+  getRelatedCnsts,
+  type Module,
+  ModuleExecutor,
+  type Sys,
+  script,
+  type Workspace,
+} from "akanjs/devkit";
+
+import { PageScript } from "../page/page.script";
+import * as request from "./module.request";
+import { ModuleRequest } from "./module.request";
+import { ModuleRunner } from "./module.runner";
+
+export class ModuleScript extends script("module", [ModuleRunner, PageScript]) {
+  async createModuleTemplate(sys: Sys, name: string, { page = false }: { page?: boolean } = {}) {
+    const mod = ModuleExecutor.from(sys, name);
+    await this.moduleRunner.createModuleTemplate(mod);
+    if (page && sys.type === "app")
+      await this.pageScript.createCrudPage(mod, { app: sys as App, basePath: null, single: false });
+    await sys.scan();
+  }
+  async createModule(sys: Sys, name: string, description?: string, schemaDescription?: string) {
+    const session = new AiSession("createModule", { workspace: sys.workspace, cacheKey: name });
+    const [appNames, libNames] = await sys.workspace.getSyss();
+    const moduleConstantExampleFiles = await sys.workspace.getConstantFiles();
+    const moduleDictionaryExampleFiles = await sys.workspace.getDictionaryFiles();
+    
+    const executor = ModuleExecutor.from(sys, name);
+    const { constant, dictionary } = await this.moduleRunner.createModuleTemplate(executor);
+    sys.log(`Module ${name} created in ${sys.type}s/${sys.name}/lib/${name}`);
+
+    const config = await sys.getConfig();
+    const moduleRequest = new ModuleRequest({ sysType: sys.type, sysName: sys.name, modelName: name, config });
+    const constantRequestPrompt = await moduleRequest.requestModelConstant({
+      modelDesc: description ?? "",
+      modelSchemaDesign: schemaDescription ?? "",
+      boilerplate: constant.content,
+      exampleFiles: randomPicks(moduleConstantExampleFiles, Math.min(10, moduleConstantExampleFiles.length)),
+    });
+    const constantContent = await session.editTypescript(constantRequestPrompt, { validate: [] });
+
+    await sys.writeFile(`lib/${name}/${name}.constant.ts`, constantContent);
+
+    const dictionaryContent = await session.editTypescript(
+      request.requestDictionary({
+        sysName: sys.name,
+        modelName: name,
+        constant: constantContent,
+        modelDesc: description ?? "",
+        modelSchemaDesign: schemaDescription ?? "",
+        boilerplate: dictionary.content,
+        exampleFiles: randomPicks(moduleConstantExampleFiles, Math.min(10, moduleConstantExampleFiles.length)),
+      }),
+    );
+    await sys.writeFile(`lib/${name}/${name}.dictionary.ts`, dictionaryContent);
+
+    await this.createView(executor);
+    await this.createUnit(executor);
+    await this.createTemplate(executor);
+    sys.log(`Module ${name} created in ${sys.type}s/${sys.name}/lib/${name}`);
+  }
+  async createModule_(sys: Sys, name: string, description: string, schemaDescription: string) {
+    const session = new AiSession("createModule", { workspace: sys.workspace, cacheKey: name });
+    const [appNames, libNames] = await sys.workspace.getSyss();
+    const moduleConstantExampleFiles = await sys.workspace.getConstantFiles();
+    const moduleDictionaryExampleFiles = await sys.workspace.getDictionaryFiles();
+    
+    const executor = ModuleExecutor.from(sys, name);
+    
+    sys.log(`Module ${name} created in ${sys.type}s/${sys.name}/lib/${name}`);
+
+    await this.createView(executor);
+    await this.createUnit(executor);
+    await this.createTemplate(executor);
+    sys.log(`Module ${name} created in ${sys.type}s/${sys.name}/lib/${name}`);
+  }
+  async removeModule(mod: Module) {
+    await this.moduleRunner.removeModule(mod);
+  }
+  async createService(workspace: Workspace, name: string) {
+  }
+  async createTest(workspace: Workspace, name: string) {
+  }
+  async createTemplate(mod: Module) {
+    const { component: template } = await this.moduleRunner.createComponentTemplate(mod, "template");
+    const templateExampleFiles = (await mod.sys.getTemplatesSourceCode()).filter(
+      (f) => !f.filePath.includes(`${mod.name}.Template.tsx`),
+    );
+    const Name = capitalize(mod.name);
+    const relatedCnsts = getRelatedCnsts(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
+    const constant = await FileSys.readText(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
+    const session = new AiSession("createTemplate", { workspace: mod.sys.workspace, cacheKey: mod.name });
+    const promptRst = request.requestTemplate({
+      sysName: mod.sys.name,
+      modelName: mod.name,
+      ModelName: Name,
+      constant: constant,
+      boilerplate: template.content,
+      properties: relatedCnsts.map((r) => ({ key: r.key, source: r.source })),
+      exampleFiles: randomPicks(templateExampleFiles, Math.min(20, templateExampleFiles.length)),
+    });
+    const content = await session.editTypescript(promptRst);
+
+    mod.writeFile(`${Name}.Template.tsx`, content);
+  }
+
+  async createUnit(mod: Module) {
+    const { component: unit } = await this.moduleRunner.createComponentTemplate(mod, "unit");
+    const Name = capitalize(mod.name);
+    const unitExampleFiles = (await mod.sys.getUnitsSourceCode()).filter(
+      (f) => !f.filePath.includes(`${mod.name}.Unit.tsx`),
+    );
+    const relatedCnsts = getRelatedCnsts(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
+    const constant = await FileSys.readText(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
+    const session = new AiSession("createUnit", { workspace: mod.sys.workspace, cacheKey: mod.name });
+
+    const promptRst = request.requestUnit({
+      sysName: mod.sys.name,
+      modelName: mod.name,
+      ModelName: Name,
+      constant: constant,
+      properties: relatedCnsts.map((r) => ({ key: r.key, source: r.source })),
+      exampleFiles: randomPicks(unitExampleFiles, Math.min(10, unitExampleFiles.length)),
+      boilerplate: unit.content,
+    });
+
+    const content = await session.editTypescript(promptRst);
+
+    mod.writeFile(`${Name}.Unit.tsx`, content);
+  }
+
+  async createView(mod: Module) {
+    const { component: view } = await this.moduleRunner.createComponentTemplate(mod, "view");
+    const viewExampleFiles = (await mod.sys.getViewsSourceCode()).filter(
+      (f) => !f.filePath.includes(`${mod.name}.View.tsx`),
+    );
+    const Name = capitalize(mod.name);
+    const relatedCnsts = getRelatedCnsts(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
+    const constant = await FileSys.readText(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
+    const session = new AiSession("createView", { workspace: mod.sys.workspace, cacheKey: mod.name });
+    const promptRst = request.requestView({
+      sysName: mod.sys.name,
+      modelName: mod.name,
+      ModelName: Name,
+      constant: constant,
+      boilerplate: view.content,
+      properties: relatedCnsts.map((r) => ({ key: r.key, source: r.source })),
+      exampleFiles: randomPicks(viewExampleFiles, Math.min(20, viewExampleFiles.length)),
+    });
+
+    const content = await session.editTypescript(promptRst);
+
+    mod.writeFile(`${Name}.View.tsx`, content);
+  }
+}
+

package/cli/package/package.command.ts

@@ -0,0 +1,32 @@
+import { command, Pkg, Workspace } from "akanjs/devkit";
+
+import { PackageScript } from "./package.script";
+
+export class PackageCommand extends command("package", [PackageScript], ({ public: target }) => ({
+  version: target({ desc: "Show version information for all packages" })
+    .with(Workspace)
+    .exec(async function (workspace) {
+      await this.packageScript.version(workspace);
+    }),
+  createPackage: target({ desc: "Create a new package in pkgs/akanjs/" })
+    .option("name", String, { desc: "name of package" })
+    .with(Workspace)
+    .exec(async function (name, workspace) {
+      await this.packageScript.createPackage(workspace, name.toLowerCase().replace(/ /g, "-"));
+    }),
+  removePackage: target({ desc: "Remove a package from the workspace" })
+    .with(Pkg)
+    .exec(async function (pkg) {
+      await this.packageScript.removePackage(pkg);
+    }),
+  syncPackage: target({ desc: "Sync dependencies and configuration for a package" })
+    .with(Pkg)
+    .exec(async function (pkg) {
+      await this.packageScript.syncPackage(pkg);
+    }),
+  buildPackage: target({ desc: "Build a package for distribution" })
+    .with(Pkg)
+    .exec(async function (pkg) {
+      await this.packageScript.buildPackage(pkg);
+    }),
+})) {}

package/cli/package/package.runner.ts

@@ -0,0 +1,64 @@
+import { Logger } from "akanjs/common";
+import {
+  FileSys,
+  type PackageJson,
+  type Pkg,
+  runner,
+  TypeScriptDependencyScanner,
+  type Workspace,
+} from "akanjs/devkit";
+import { $ } from "bun";
+
+export class PackageRunner extends runner("package") {
+  async version(workspace: Workspace) {
+    const pkgJson = await FileSys.readJson<PackageJson>("package.json");
+    const version = pkgJson.version;
+    Logger.rawLog(`${pkgJson.name}@${version}`);
+  }
+  async createPackage(workspace: Workspace, pkgName: string) {
+    await workspace.applyTemplate({ basePath: `pkgs/${pkgName}`, template: "pkgRoot", dict: { pkgName } });
+    await workspace.setTsPaths("pkg", pkgName);
+  }
+  async removePackage(pkg: Pkg) {
+    await pkg.workspace.exec(`rm -rf pkgs/${pkg.name}`);
+    await pkg.workspace.unsetTsPaths("pkg", pkg.name);
+  }
+  async scanSync(pkg: Pkg) {
+    const scanResult = await pkg.scan();
+    return scanResult;
+  }
+  async buildPackage(pkg: Pkg) {
+    await $`rm -rf ${pkg.dist.cwdPath}`;
+    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 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 $`cp -r ${pkg.cwdPath}/. ${pkg.dist.cwdPath}`;
+      await Promise.all([pkg.generateDistPackageJson(npmDeps, npmDevDeps), pkg.generateTsconfigJson()]);
+    }
+  }
+
+  async updateWorskpaceRootPackageJson(workspace: Workspace, rootPackageJson: PackageJson) {
+    const templatePath = "pkgs/akanjs/cli/templates/workspaceRoot/package.json.template";
+    const pkgJsonTemplate = (await workspace.readJson(templatePath)) as PackageJson;
+    const { dependencies = {}, devDependencies = {} } = pkgJsonTemplate;
+    const newRootPackageJson = {
+      ...pkgJsonTemplate,
+      dependencies: Object.fromEntries(
+        Object.entries(dependencies).map(([key, value]) => [key, rootPackageJson.dependencies?.[key] ?? value]),
+      ),
+      devDependencies: Object.fromEntries(
+        Object.entries(devDependencies).map(([key, value]) => [key, rootPackageJson.devDependencies?.[key] ?? value]),
+      ),
+    };
+    await workspace.writeJson(templatePath, newRootPackageJson);
+  }
+}

package/cli/package/package.script.ts

@@ -0,0 +1,35 @@
+import { type Pkg, script, type Workspace } from "akanjs/devkit";
+
+import { PackageRunner } from "./package.runner";
+
+export class PackageScript extends script("package", [PackageRunner]) {
+  async version(workspace: Workspace) {
+    await this.packageRunner.version(workspace);
+  }
+  async createPackage(workspace: Workspace, pkgName: string) {
+    const spinner = workspace.spinning(`Creating package in pkgs/${pkgName}...`);
+    await this.packageRunner.createPackage(workspace, pkgName);
+    spinner.succeed(`Package in pkgs/${pkgName} is created`);
+  }
+  async removePackage(pkg: Pkg) {
+    const spinner = pkg.spinning(`Removing package in pkgs/${pkg.name}...`);
+    await this.packageRunner.removePackage(pkg);
+    spinner.succeed("Package removed");
+  }
+  async syncPackage(pkg: Pkg) {
+    const spinner = pkg.spinning("Scanning package...");
+    const scanResult = await this.packageRunner.scanSync(pkg);
+    spinner.succeed("Package scanned");
+    return scanResult;
+  }
+
+  async buildPackage(pkg: Pkg, { showSpinner = true }: { showSpinner?: boolean } = {}) {
+    const spinner = showSpinner ? pkg.spinning("Building package...") : undefined;
+    await this.packageRunner.buildPackage(pkg);
+    if (spinner) spinner.succeed("Package built");
+  }
+  async updateWorskpaceRootPackageJson(workspace: Workspace) {
+    const rootPackageJson = await workspace.getPackageJson();
+    await this.packageRunner.updateWorskpaceRootPackageJson(workspace, rootPackageJson);
+  }
+}

package/cli/page/page.command.ts

@@ -0,0 +1,14 @@
+import { App, command, Module } from "akanjs/devkit";
+
+import { PageScript } from "./page.script";
+
+export class PageCommand extends command("page", [PageScript], ({ public: target }) => ({
+  createCrudPage: target({ desc: "Create CRUD pages for a module (list, detail, create, edit)" })
+    .with(App)
+    .with(Module)
+    .option("basePath", String, { desc: "base path", nullable: true })
+    .option("single", Boolean, { desc: "single page", default: false })
+    .exec(async function (app, module, basePath, single) {
+      await this.pageScript.createCrudPage(module, { app, basePath, single });
+    }),
+})) {}

package/cli/page/page.runner.ts

@@ -0,0 +1,14 @@
+import { type App, type Module, runner } from "akanjs/devkit";
+
+export class PageRunner extends runner("page") {
+  async createCrudPage(
+    module: Module,
+    { app, basePath, single = false }: { app: App; basePath: string | null; single: boolean },
+  ) {
+    await app.applyTemplate({
+      basePath: basePath ?? `page/(${app.name})/(public)/${module.name}`,
+      template: single ? "crudSinglePage" : "crudPages",
+      dict: { model: module.name, appName: module.sys.name },
+    });
+  }
+}

package/cli/page/page.script.ts

@@ -0,0 +1,12 @@
+import { type App, type Module, script } from "akanjs/devkit";
+
+import { PageRunner } from "./page.runner";
+
+export class PageScript extends script("page", [PageRunner]) {
+  async createCrudPage(
+    module: Module,
+    { app, basePath, single = false }: { app: App; basePath: string | null; single: boolean },
+  ) {
+    await this.pageRunner.createCrudPage(module, { app, basePath, single });
+  }
+}

package/cli/scalar/scalar.command.ts

@@ -0,0 +1,21 @@
+import { lowerlize } from "akanjs/common";
+import { command, Sys } from "akanjs/devkit";
+
+import { ScalarScript } from "./scalar.script";
+
+export class ScalarCommand extends command("scalar", [ScalarScript], ({ public: target }) => ({
+  createScalar: target({ desc: "Create a new scalar type (simple data model without DB)" })
+    .arg("scalarName", String, { desc: "name of scalar" })
+    .option("ai", Boolean, { default: false, desc: "use ai to create scalar" })
+    .with(Sys)
+    .exec(async function (scalarName, ai, sys) {
+      if (ai) await this.scalarScript.createScalarWithAi(sys, lowerlize(scalarName.replace(/ /g, "")));
+      await this.scalarScript.createScalar(sys, lowerlize(scalarName.replace(/ /g, "")));
+    }),
+  removeScalar: target({ desc: "Remove a scalar type from an app or library" })
+    .arg("scalarName", String, { desc: "name of scalar" })
+    .with(Sys)
+    .exec(async function (scalarName, sys) {
+      await this.scalarScript.removeScalar(sys, scalarName);
+    }),
+})) {}

package/cli/scalar/scalar.prompt.ts

@@ -0,0 +1,131 @@
+import { input } from "@inquirer/prompts";
+import { type FileContent, Prompter, type Sys } from "akanjs/devkit";
+import pluralize from "pluralize";
+
+export class ScalarPrompt extends Prompter {
+  constructor(
+    readonly sys: Sys,
+    readonly name: string,
+  ) {
+    super();
+  }
+  async requestUpdateConstant() {
+    const request = await input({ message: `What do you want to change?` });
+    return { request, validate: undefined };
+  }
+  async requestCreateConstant() {
+    const constantFiles = await this.sys.getConstantFilesWithLibs();
+    const description = await input({ message: "description of scalar" });
+    const schemaDescription = await input({ message: "schema description of scalar" });
+    await this.sys.applyTemplate({
+      basePath: "./lib/__scalar",
+      template: "__scalar",
+      dict: { model: this.name, models: pluralize(this.name), sysName: this.sys.name },
+    });
+    const boilerplate = await this.sys.readFile(`lib/__scalar/${this.name}/${this.name}.constant.ts`);
+    return await this.#requestConstant({
+      modelDesc: description,
+      modelSchemaDesign: schemaDescription,
+      boilerplate,
+      constantFiles,
+    });
+  }
+  async #requestConstant({
+    modelDesc,
+    modelSchemaDesign,
+    boilerplate,
+    constantFiles,
+  }: {
+    modelDesc: string;
+    modelSchemaDesign: string;
+    boilerplate: string;
+    constantFiles: FileContent[];
+  }): Promise<{ request: string; validate: string[] }> {
+    const scanInfo = await this.sys.scan();
+    const guideJson = await Prompter.getGuideJson("scalarConstant");
+    const request = await this.makeTsFileUpdatePrompt({
+      context: `
+1. Overview of __scalar/<model>/<model>.constant.ts file
+${await this.getDocumentation("scalarConstant")}
+
+2. How to write Enums in __scalar/<model>/<model>.constant.ts file
+${await this.getDocumentation("enumConstant")}
+
+3. How to write Fields in __scalar/<model>/<model>.constant.ts file
+${await this.getDocumentation("fieldDecorator")}
+
+4. List of constant.ts files in other libraries connected to current ${this.sys.name} ${this.sys.type === "app" ? "Application" : "Library"} ${scanInfo
+        .getLibs()
+        .map((lib) => lib)
+        .join(", ")}
+Please understand the content and file patterns below, and feel free to reuse any constants or enums if available.
+${constantFiles
+  .map(
+    (constant) => `
+\`\`\`typescript
+${constant.content}
+\`\`\`
+`,
+  )
+  .join("\n")}
+		`,
+      request: `
+Based on the above content, please organize it according to the boilerplate below for easy parsing
+
+Application name: ${this.sys.name} (${this.sys.type === "app" ? "Application" : "Library"})
+Model name: ${this.name}
+Model description: ${modelDesc}
+Model schema design: ${modelSchemaDesign}
+Model filename(You can create another connected scalar model file if needed): ${this.name}.constant.ts
+\`\`\`typescript
+${boilerplate}
+\`\`\`
+
+If additional connected scalar models need to be written besides ${this.name}.constant.ts file, please write them in the following format
+\`\`\`typescript
+...file content
+\`\`\`
+
+Please provide only the file results without any other content.`,
+    });
+    return { request, validate: guideJson.update.rules };
+  }
+  async requestUpdateDictonaryWithInstruction() {
+    const constant = await this.sys.readFile(`lib/__scalar/${this.name}/${this.name}.constant.ts`);
+    const boilerplate = await this.sys.readFile(`lib/__scalar/${this.name}/${this.name}.dictionary.ts`);
+    const guideJson = await Prompter.getGuideJson("scalarDictionary");
+    const request = `다음 ${this.name}.dictionary.ts 파일도 완성된 ${this.name}.constant.ts 파일을 기반으로 작성해줘.
+1. Dictionary 작성법
+${await this.getDocumentation("scalarDictionary")}
+
+Model constant file
+\`\`\`typescript
+${constant}
+\`\`\`
+
+Model filename: ${this.name}.dictionary.ts
+\`\`\`typescript
+${boilerplate}
+\`\`\`
+  `;
+    return { request, validate: guideJson.update.rules };
+  }
+  async requestUpdateDictonaryWithFollowing() {
+    const [constant, boilerplate] = await Promise.all([
+      this.sys.readFile(`lib/__scalar/${this.name}/${this.name}.constant.ts`),
+      this.sys.readFile(`lib/__scalar/${this.name}/${this.name}.dictionary.ts`),
+    ]);
+    const request = `다음 ${this.name}.dictionary.ts 파일도 완성된 ${this.name}.constant.ts 파일을 기반으로 작성해줘.
+Model constant file
+\`\`\`typescript
+${constant}
+\`\`\`
+
+Model filename: ${this.name}.dictionary.ts
+\`\`\`typescript
+${boilerplate}
+\`\`\`
+  `;
+    return { request, validate: [] as string[] };
+  }
+}

package/cli/scalar/scalar.runner.ts

@@ -0,0 +1,38 @@
+import { AiSession, runner, type Sys } from "akanjs/devkit";
+import pluralize from "pluralize";
+
+import { ScalarPrompt } from "./scalar.prompt";
+
+export class ScalarRunner extends runner("scalar") {
+  async applyScalarTemplate(sys: Sys, scalarName: string) {
+    await sys.applyTemplate({
+      basePath: "./lib/__scalar",
+      template: "__scalar",
+      dict: { model: scalarName, models: pluralize(scalarName), sysName: sys.name },
+      overwrite: false,
+    });
+  }
+  async createScalarConstant(sys: Sys, scalarName: string) {
+    const isContinued = await sys.exists(`lib/__scalar/${scalarName}/${scalarName}.constant.ts`);
+    const prompt = new ScalarPrompt(sys, scalarName);
+    const session = new AiSession("createScalar", { workspace: sys.workspace, cacheKey: scalarName, isContinued });
+    const { request, validate } = session.isCacheLoaded
+      ? await prompt.requestUpdateConstant()
+      : await prompt.requestCreateConstant();
+    const writes = await session.writeTypescripts(request, sys, { validate });
+    const scalarNames = writes.map(({ filePath }) => filePath.split("/").at(-2)).filter((name) => !!name) as string[];
+    for (const name of scalarNames) await this.applyScalarTemplate(sys, name);
+    return { session, scalarNames, writes, prompt };
+  }
+  async updateScalarDictionaries(sys: Sys, scalarNames: string[], { session }: { session: AiSession }) {
+    const [firstScalarName, ...followingScalarNames] = scalarNames;
+    const prompt = new ScalarPrompt(sys, firstScalarName);
+    const { request, validate } = await prompt.requestUpdateDictonaryWithInstruction();
+    await session.writeTypescripts(request, sys, { validate });
+    for (const scalarName of followingScalarNames) {
+      const prompt = new ScalarPrompt(sys, scalarName);
+      const { request, validate } = await prompt.requestUpdateDictonaryWithFollowing();
+      await session.writeTypescripts(request, sys, { validate });
+    }
+  }
+}

package/cli/scalar/scalar.script.ts

@@ -0,0 +1,16 @@
+import { type Sys, script } from "akanjs/devkit";
+
+import { ScalarRunner } from "./scalar.runner";
+
+export class ScalarScript extends script("scalar", [ScalarRunner]) {
+  async createScalar(sys: Sys, scalarName: string) {
+    await this.scalarRunner.applyScalarTemplate(sys, scalarName);
+  }
+  async createScalarWithAi(sys: Sys, scalarName: string) {
+    const { session, scalarNames } = await this.scalarRunner.createScalarConstant(sys, scalarName);
+    await this.scalarRunner.updateScalarDictionaries(sys, scalarNames, { session });
+  }
+  async removeScalar(sys: Sys, scalarName: string) {
+    await sys.removeDir(`lib/__scalar/${scalarName}`);
+  }
+}

package/cli/templates/__scalar/__model__/__model__.constant.ts

@@ -0,0 +1,15 @@
+import type { AppInfo, LibInfo } from "akanjs/devkit";
+
+interface Dict {
+  model: string;
+  Model: string;
+}
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: Dict) {
+  return `
+import { via } from "akanjs/constant";
+
+export class ${dict.Model} extends via((field) => ({
+  field: field(String),
+})) {}
+`;
+}

package/cli/templates/__scalar/__model__/__model__.dictionary.ts

@@ -0,0 +1,19 @@
+import type { AppInfo, LibInfo } from "akanjs/devkit";
+
+interface Dict {
+  model: string;
+  Model: string;
+}
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: Dict) {
+  return `
+import { scalarDictionary } from "akanjs/dictionary";
+
+import type { ${dict.Model} } from "./${dict.model}.constant";
+
+export const dictionary = scalarDictionary(["en", "ko"])
+  .of((t) => t(["${dict.Model}", "${dict.Model}"]).desc(["${dict.Model} description", "${dict.Model} 설명"]))
+  .model<${dict.Model}>((t) => ({
+    field: t(["Field", "필드"]).desc(["Field Description", "필드 설명"]),
+  }));
+`;
+}

package/cli/templates/__scalar/__model__/__model__.document.ts

@@ -0,0 +1,15 @@
+import type { AppInfo, LibInfo } from "akanjs/devkit";
+
+interface Dict {
+  model: string;
+  Model: string;
+}
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: Dict) {
+  return `
+import { by } from "akanjs/document";
+
+import * as cnst from "./${dict.model}.constant";
+
+export class ${dict.Model} extends by(cnst.${dict.Model}) {}
+`;
+}

package/cli/templates/app/akan.config.ts

@@ -0,0 +1,14 @@
+import type { AppInfo, LibInfo } from "akanjs/devkit";
+
+interface Dict {
+  appName: string;
+}
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: Dict) {
+  return `
+import type { AppConfig } from "akanjs/devkit";
+
+const config: AppConfig = {};
+
+export default config;
+  `;
+}

package/cli/templates/app/capacitor.config.ts.template

@@ -0,0 +1,8 @@
+//! will be replaced with akan.config.ts
+import { withBase } from "akanjs/devkit/capacitor.base.config";
+
+export default withBase((config) => {
+  return {
+    ...config,
+  };
+});

package/cli/templates/app/common/commonLogic.ts

@@ -0,0 +1,12 @@
+import type { AppInfo, LibInfo } from "akanjs/devkit";
+
+interface Dict {
+  appName: string;
+}
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: Dict) {
+  return `
+
+export const someCommonLogic = () => {
+};
+  `;
+}

package/cli/templates/app/common/index.ts

@@ -0,0 +1,10 @@
+import type { AppInfo, LibInfo } from "akanjs/devkit";
+
+interface Dict {
+  [key: string]: string;
+}
+export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: Dict = {}) {
+  return `
+export * from "./commonLogic";
+  `;
+}

package/cli/templates/app/env/env.client.debug.ts.template

@@ -0,0 +1,7 @@
+import { getEnv } from "akanjs/base";
+
+import type { AppClientEnv } from "./env.client.type";
+
+export const env: AppClientEnv = {
+  ...getEnv(),
+} as const;

package/cli/templates/app/env/env.client.develop.ts.template

@@ -0,0 +1,7 @@
+import { getEnv } from "akanjs/base";
+
+import type { AppClientEnv } from "./env.client.type";
+
+export const env: AppClientEnv = {
+  ...getEnv(),
+} as const;