akanjs 2.0.6 → 2.1.0-rc.0

package/cli/module/module.script.ts

@@ -1,161 +0,0 @@
-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/npmRegistry.ts

@@ -1,13 +0,0 @@
-interface NpmPackageMetadata {
-  "dist-tags"?: Record<string, string>;
-}
-
-export async function getLatestPackageVersion(packageName: string, tag = "latest"): Promise<string> {
-  const url = `https://registry.npmjs.org/${encodeURIComponent(packageName).replace(/^%40/, "@")}`;
-  const res = await fetch(url);
-  if (!res.ok) throw new Error(`Failed to fetch ${packageName} metadata from npm registry`);
-  const metadata = (await res.json()) as NpmPackageMetadata;
-  const version = metadata["dist-tags"]?.[tag];
-  if (!version) throw new Error(`No npm dist-tag "${tag}" found for ${packageName}`);
-  return version;
-}

package/cli/openBrowser.ts

@@ -1,15 +0,0 @@
-import { spawn } from "node:child_process";
-
-export function openBrowser(url: string): Promise<void> {
-  const command =
-    process.platform === "darwin"
-      ? ["open", url]
-      : process.platform === "win32"
-        ? ["cmd", "/c", "start", "", url]
-        : ["xdg-open", url];
-  const child = spawn(command[0], command.slice(1), { detached: true, stdio: "ignore" });
-  child.on("error", () => {
-  });
-  child.unref();
-  return Promise.resolve();
-}

package/cli/package/package.command.ts

@@ -1,32 +0,0 @@
-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

@@ -1,94 +0,0 @@
-import path from "node:path";
-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 | null, { log = true }: { log?: boolean } = {}) {
-    const pkgJson = await FileSys.readJson<PackageJson>(
-      process.env.USE_AKANJS_PKGS === "true"
-        ? `${workspace?.workspaceRoot ?? process.cwd()}/pkgs/akanjs/package.json`
-        : `${path.dirname(Bun.main)}/../package.json`,
-    );
-    const version = pkgJson.version;
-    if (log) Logger.rawLog(`${pkgJson.name}@${version}`);
-    return version;
-  }
-  async createPackage(workspace: Workspace, pkgName: string) {
-    await workspace.applyTemplate({ basePath: `pkgs/${pkgName}`, template: "pkgRoot", dict: { pkgName } });
-    await workspace.setPkgTsPaths(pkgName);
-  }
-  async removePackage(pkg: Pkg) {
-    await pkg.workspace.exec(`rm -rf pkgs/${pkg.name}`);
-    await pkg.workspace.unsetPkgTsPaths(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);
-    const packageRuntimeDependencies: Record<string, string[]> = {};
-    const packageRuntimeDevDependencies: Record<string, string[]> = { akanjs: ["@biomejs/biome", "@types/bun"] };
-    const forcedRuntimeDeps = packageRuntimeDependencies[pkg.name] ?? [];
-    const forcedRuntimeDevDeps = packageRuntimeDevDependencies[pkg.name] ?? [];
-    const [rootPackageJson, pkgJson] = await Promise.all([pkg.workspace.getPackageJson(), pkg.getPackageJson()]);
-    const optionalPeerDeps = new Set(
-      Object.entries(pkgJson.peerDependenciesMeta ?? {})
-        .filter(([, meta]) => meta.optional)
-        .map(([dep]) => dep),
-    );
-    const packageRuntimeDeps = [...new Set([...npmDeps, ...forcedRuntimeDeps])].filter(
-      (dep) => !optionalPeerDeps.has(dep),
-    );
-    const packageRuntimeDevDeps = [...new Set([...npmDevDeps, ...forcedRuntimeDevDeps])].filter(
-      (dep) => !optionalPeerDeps.has(dep),
-    );
-    const rootDeps = { ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies };
-    const missingForcedDeps = forcedRuntimeDeps.filter((dep) => !rootDeps[dep]);
-    const missingForcedDevDeps = forcedRuntimeDevDeps.filter((dep) => !rootDeps[dep]);
-    const requiredMissingDeps = missingDeps.filter((dep) => !optionalPeerDeps.has(dep));
-    const allMissingDeps = [...new Set([...requiredMissingDeps, ...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 $`cp -r ${pkg.cwdPath}/. ${pkg.dist.cwdPath}`;
-      await Promise.all([
-        pkg.generateDistPackageJson(packageRuntimeDeps, packageRuntimeDevDeps),
-        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

@@ -1,35 +0,0 @@
-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 | null, { log = true }: { log?: boolean } = {}) {
-    return await this.packageRunner.version(workspace, { log });
-  }
-  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

@@ -1,14 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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/pluralizeName.ts

@@ -1,5 +0,0 @@
-export function pluralizeName(name: string): string {
-  if (/[^aeiou]y$/i.test(name)) return `${name.slice(0, -1)}ies`;
-  if (/(s|x|z|ch|sh)$/i.test(name)) return `${name}es`;
-  return `${name}s`;
-}

package/cli/scalar/scalar.command.ts

@@ -1,21 +0,0 @@
-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

@@ -1,131 +0,0 @@
-import { input } from "@inquirer/prompts";
-import { type FileContent, Prompter, type Sys } from "akanjs/devkit";
-import { pluralizeName } from "../pluralizeName";
-
-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: pluralizeName(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

@@ -1,38 +0,0 @@
-import { AiSession, runner, type Sys } from "akanjs/devkit";
-import { pluralizeName } from "../pluralizeName";
-
-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: pluralizeName(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

@@ -1,16 +0,0 @@
-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/semver.ts

@@ -1,18 +0,0 @@
-function parseVersion(version: string): number[] {
-  return version
-    .replace(/^[^\d]*/, "")
-    .split(/[.-]/)
-    .map((part) => Number.parseInt(part, 10))
-    .map((part) => (Number.isFinite(part) ? part : 0));
-}
-
-export function compareSemver(a: string, b: string): number {
-  const left = parseVersion(a);
-  const right = parseVersion(b);
-  const length = Math.max(left.length, right.length);
-  for (let i = 0; i < length; i++) {
-    const diff = (left[i] ?? 0) - (right[i] ?? 0);
-    if (diff !== 0) return diff > 0 ? 1 : -1;
-  }
-  return 0;
-}

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

@@ -1,15 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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", "필드 설명"]),
-  }));
-`;
-}