akanjs 0.0.1 → 2.0.0-beta.0

package/devkit/linter.ts

@@ -0,0 +1,248 @@
+import { existsSync, readFileSync } from "node:fs";
+import * as path from "node:path";
+import { Logger } from "akanjs/common";
+import chalk from "chalk";
+
+export class Linter {
+  #logger = new Logger("Linter");
+  
+  lintRoot: string;
+
+  constructor(cwdPath: string) {
+    this.lintRoot = this.#findEslintRootPath(cwdPath);
+  }
+  #findEslintRootPath(dir: string): string {
+    const configPath = path.join(dir, "eslint.config.ts");
+    if (existsSync(configPath)) return dir;
+    const parentDir = path.dirname(dir);
+    return this.#findEslintRootPath(parentDir);
+  }
+  async lint(filePath: string, { fix = false, dryRun = false }: { fix?: boolean; dryRun?: boolean } = {}) {
+    if (fix) return await this.fixFile(filePath, dryRun);
+    return await this.lintFile(filePath);
+  }
+
+  /**
+   * Lint a single file using ESLint
+   * @param filePath - Path to the file to lint
+   * @returns Array of ESLint results
+   */
+  async lintFile(filePath: string): Promise<{
+    fixed: boolean;
+    output?: string;
+    results: any[]; 
+    errors: any[]; 
+    warnings: any[]; 
+  }> {
+    if (!existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
+
+    return { fixed: false, results: [], errors: [], warnings: [] };
+  }
+
+  /**
+   * Format lint results for console output
+   * @param results - Array of ESLint results
+   * @returns Formatted string
+   */
+  formatLintResults(results: any[]): string {
+    
+    if (results.length === 0) return "No files to lint";
+
+    const output: string[] = [];
+    let totalErrors = 0;
+    let totalWarnings = 0;
+
+    results.forEach((result) => {
+      totalErrors += result.errorCount;
+      totalWarnings += result.warningCount;
+
+      if (result.messages.length > 0) {
+        output.push(`\n${chalk.cyan(result.filePath)}`);
+
+        let sourceLines: string[] = [];
+        if (existsSync(result.filePath)) {
+          try {
+            const sourceContent = readFileSync(result.filePath, "utf8");
+            sourceLines = sourceContent.split("\n");
+          } catch (error) {
+          }
+        }
+
+        result.messages.forEach((message: any) => {
+          const type = message.severity === 2 ? "error" : "warning";
+          const typeColor = message.severity === 2 ? chalk.red : chalk.yellow;
+          const icon = message.severity === 2 ? "❌" : "⚠️";
+          const ruleInfo = message.ruleId ? chalk.dim(` (${message.ruleId})`) : "";
+
+          output.push(`\n  ${icon} ${typeColor(type)}: ${message.message}${ruleInfo}`);
+          output.push(`     ${chalk.gray("at")} ${result.filePath}:${chalk.bold(`${message.line}:${message.column}`)}`);
+
+          if (sourceLines.length > 0 && message.line <= sourceLines.length) {
+            const sourceLine = sourceLines[message.line - 1];
+            const lineNumber = message.line.toString().padStart(5, " ");
+
+            output.push(`\n${chalk.dim(`${lineNumber} |`)} ${sourceLine}`);
+
+            const underlinePrefix = " ".repeat(message.column - 1);
+            const underlineLength = message.endColumn ? message.endColumn - message.column : 1;
+            const underline = "^".repeat(Math.max(1, underlineLength));
+
+            output.push(`${chalk.dim(`${" ".repeat(lineNumber.length)} |`)} ${underlinePrefix}${typeColor(underline)}`);
+          }
+        });
+      }
+    });
+
+    if (totalErrors === 0 && totalWarnings === 0) return chalk.bold("✅ No ESLint errors or warnings found");
+
+    const errorText = totalErrors > 0 ? chalk.red(`${totalErrors} error(s)`) : "0 errors";
+    const warningText = totalWarnings > 0 ? chalk.yellow(`${totalWarnings} warning(s)`) : "0 warnings";
+    const summary = [`\n${errorText}, ${warningText} found`];
+
+    return summary.concat(output).join("\n");
+  }
+
+  /**
+   * Get detailed lint information
+   * @param filePath - Path to the file to lint
+   * @returns Object containing detailed lint information
+   */
+  async getDetailedLintInfo(filePath: string): Promise<{
+    results: any[]; 
+    details: {
+      line: number;
+      column: number;
+      message: string;
+      ruleId: string | null;
+      severity: "error" | "warning";
+      fix?: {
+        range: [number, number];
+        text: string;
+      };
+      suggestions?: {
+        desc: string;
+        fix: {
+          range: [number, number];
+          text: string;
+        };
+      }[];
+    }[];
+    stats: {
+      errorCount: number;
+      warningCount: number;
+      fixableErrorCount: number;
+      fixableWarningCount: number;
+    };
+  }> {
+    const { results } = await this.lintFile(filePath);
+
+    const details = results.flatMap((result) =>
+      result.messages.map((message: any) => ({
+        line: message.line,
+        column: message.column,
+        message: message.message,
+        ruleId: message.ruleId,
+        severity: message.severity === 2 ? ("error" as const) : ("warning" as const),
+        fix: message.fix,
+        suggestions: message.suggestions,
+      })),
+    );
+
+    const stats = results.reduce(
+      (acc, result) => ({
+        errorCount: acc.errorCount + result.errorCount,
+        warningCount: acc.warningCount + result.warningCount,
+        fixableErrorCount: acc.fixableErrorCount + result.fixableErrorCount,
+        fixableWarningCount: acc.fixableWarningCount + result.fixableWarningCount,
+      }),
+      { errorCount: 0, warningCount: 0, fixableErrorCount: 0, fixableWarningCount: 0 },
+    );
+
+    return { results, details, stats };
+  }
+
+  /**
+   * Check if a file has lint errors
+   * @param filePath - Path to the file to check
+   * @returns true if there are no errors, false otherwise
+   */
+  async hasNoLintErrors(filePath: string): Promise<boolean> {
+    try {
+      const { results } = await this.lintFile(filePath);
+      return results.every((result) => result.errorCount === 0);
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get only error messages (excluding warnings)
+   * @param filePath - Path to the file to lint
+   * @returns Array of error messages
+   */
+  async getErrors(filePath: string): Promise<any[]> {
+    
+    const { results } = await this.lintFile(filePath);
+    return results.flatMap((result) => result.messages.filter((message: any) => message.severity === 2));
+  }
+
+  /**
+   * Get only warning messages
+   * @param filePath - Path to the file to lint
+   * @returns Array of warning messages
+   */
+  async getWarnings(filePath: string): Promise<any[]> {
+    
+    const { results } = await this.lintFile(filePath);
+    return results.flatMap((result) => result.messages.filter((message: any) => message.severity === 1));
+  }
+
+  /**
+   * Fix lint errors automatically
+   * @param filePath - Path to the file to fix
+   * @param dryRun - If true, returns the fixed content without writing to file
+   * @returns Fixed content and remaining issues
+   */
+  async fixFile(
+    filePath: string,
+    dryRun = false,
+  ): Promise<{
+    fixed: boolean;
+    output?: string;
+    results: any[]; 
+    errors: any[]; 
+    warnings: any[]; 
+  }> {
+    if (!existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
+
+    return { fixed: false, output: undefined, results: [], errors: [], warnings: [] };
+  }
+
+  /**
+   * Get ESLint configuration for a file
+   * @param filePath - Path to the file
+   * @returns ESLint configuration object
+   */
+  async getConfigForFile(filePath: string): Promise<unknown> {
+
+    return {};
+  }
+
+  /**
+   * Get rules that are causing errors in a file
+   * @param filePath - Path to the file to check
+   * @returns Object mapping rule IDs to their error counts
+   */
+  async getProblematicRules(filePath: string): Promise<Record<string, number>> {
+    const { results } = await this.lintFile(filePath);
+    const ruleCounts: Record<string, number> = {};
+
+    results.forEach((result) => {
+      result.messages.forEach((message: any) => {
+        if (message.ruleId) ruleCounts[message.ruleId] = (ruleCounts[message.ruleId] || 0) + 1;
+      });
+    });
+
+    return ruleCounts;
+  }
+}

package/devkit/mobile/index.ts

@@ -0,0 +1 @@
+export * from "./mobileTarget";

package/devkit/mobile/mobileTarget.ts

@@ -0,0 +1,47 @@
+import type { AkanMobileTargetConfig, MobileEnv } from "../akanConfig";
+import type { App } from "../commandDecorators";
+
+export type MobilePlatform = "ios" | "android";
+export type MobileTargetSelection = string | "all" | undefined;
+
+export interface ResolvedMobileTarget {
+  name: string;
+  config: AkanMobileTargetConfig;
+}
+
+export const MOBILE_ENVS = ["local", "debug", "develop", "main"] as const satisfies readonly MobileEnv[];
+
+export const getMobileTargets = async (app: App): Promise<ResolvedMobileTarget[]> => {
+  const config = await app.getConfig();
+  return Object.entries(config.mobile.targets).map(([name, target]) => ({ name, config: target }));
+};
+
+export const resolveMobileTargets = async (
+  app: App,
+  selection: MobileTargetSelection,
+): Promise<ResolvedMobileTarget[]> => {
+  const targets = await getMobileTargets(app);
+  if (targets.length === 0) throw new Error(`No mobile targets configured for ${app.name}`);
+  if (!selection) {
+    if (targets.length === 1) return targets;
+    throw new Error(
+      `Multiple mobile targets found for ${app.name}. Pass --target <${targets.map((t) => t.name).join("|")}|all>.`,
+    );
+  }
+  if (selection === "all") return targets;
+  const target = targets.find((candidate) => candidate.name === selection);
+  if (!target)
+    throw new Error(`Mobile target '${selection}' was not found. Available: ${targets.map((t) => t.name).join(", ")}`);
+  return [target];
+};
+
+export const resolveMobilePath = (target: AkanMobileTargetConfig, pathname: string) => {
+  const basePath = target.basePath?.replace(/^\/+|\/+$/g, "");
+  const normalizedPath = `/${pathname.replace(/^\/+/, "")}`;
+  if (!basePath) return normalizedPath;
+  if (normalizedPath === `/${basePath}` || normalizedPath.startsWith(`/${basePath}/`)) return normalizedPath;
+  return `/${basePath}${normalizedPath === "/" ? "" : normalizedPath}`;
+};
+
+export const targetHtmlFilename = (target: AkanMobileTargetConfig) =>
+  target.basePath?.replace(/^\/+|\/+$/g, "") ? `${target.basePath.replace(/^\/+|\/+$/g, "")}.html` : "index.html";

package/devkit/prompter.ts

@@ -0,0 +1,71 @@
+import fsPromise from "node:fs/promises";
+import { input, select } from "@inquirer/prompts";
+
+import { getDirname } from "./getDirname";
+import type { GuideGenerateJson } from "./guideline";
+
+interface FileUpdateRequestProps {
+  context: string;
+  request: string;
+}
+export class Prompter {
+  static async #getGuidelineRoot() {
+    const dirname = getDirname(import.meta.url);
+    const candidates = [`${dirname}/guidelines`, `${dirname}/../cli/guidelines`];
+    for (const candidate of candidates) {
+      try {
+        await fsPromise.access(candidate);
+        return candidate;
+      } catch {
+      }
+    }
+    return candidates[0];
+  }
+
+  static async selectGuideline() {
+    const guidelineRoot = await Prompter.#getGuidelineRoot();
+    const guideNames = (await fsPromise.readdir(guidelineRoot)).filter((name) => !name.startsWith("_"));
+    return await select({ message: "Select a guideline", choices: guideNames.map((name) => ({ name, value: name })) });
+  }
+  static async getGuideJson(guideName: string): Promise<GuideGenerateJson> {
+    const guidelineRoot = await Prompter.#getGuidelineRoot();
+    const filePath = `${guidelineRoot}/${guideName}/${guideName}.generate.json`;
+    const guideJson = await fsPromise.readFile(filePath, "utf-8");
+    return JSON.parse(guideJson) as GuideGenerateJson;
+  }
+  static async getInstruction(guideName: string): Promise<string> {
+    const guidelineRoot = await Prompter.#getGuidelineRoot();
+    const filePath = `${guidelineRoot}/${guideName}/${guideName}.instruction.md`;
+    const content = await fsPromise.readFile(filePath, "utf-8");
+    return content;
+  }
+  static async getUpdateRequest(guideName: string) {
+    return await input({ message: `What do you want to update in ${guideName}?` });
+  }
+
+  async makeTsFileUpdatePrompt({ context, request }: FileUpdateRequestProps) {
+    return `You are a senior developer writing TypeScript-based programs using Akan.js, an in-house framework. Here's an overview of the Akan.js framework:
+${await this.getDocumentation("framework")}
+Please understand the following background information, write code that meets the requirements, verify that it satisfies the validation conditions, and return the result.
+
+# Background Information
+\`\`\`markdown
+${context}
+\`\`\`
+
+# Requirements
+\`\`\`markdown
+${request}
+\`\`\`
+`;
+  }
+  async getDocumentation(guideName: string) {
+    const guidelineRoot = await Prompter.#getGuidelineRoot();
+    const filePath = `${guidelineRoot}/${guideName}/${guideName}.instruction.md`;
+    const document = await fsPromise.readFile(filePath, "utf-8");
+    return `\`\`\`markdown
+${document}
+\`\`\`
+`;
+  }
+}