@akanjs/devkit 0.0.142 → 0.0.144

package/src/executors.d.ts

@@ -1,14 +1,17 @@
 import { Logger } from "@akanjs/common";
 import { type AppConfigResult, AppScanResult, type LibConfigResult, LibScanResult, PkgScanResult, WorkspaceScanResult } from "@akanjs/config";
 import { type ExecOptions, type ForkOptions, type SpawnOptions } from "child_process";
+import { Linter } from "./linter";
 import { Spinner } from "./spinner";
-import type { PackageJson, TsConfigJson } from "./types";
+import { TypeChecker } from "./typeChecker";
+import type { FileContent, PackageJson, TsConfigJson } from "./types";
 export declare const execEmoji: {
     workspace: string;
     app: string;
     lib: string;
     pkg: string;
     dist: string;
+    module: string;
     default: string;
 };
 export declare class Executor {
@@ -19,23 +22,24 @@ export declare class Executor {
     logger: Logger;
     cwdPath: string;
     emoji: string;
+    typeChecker: TypeChecker | null;
+    linter: Linter | null;
     constructor(name: string, cwdPath: string);
     exec(command: string, options?: ExecOptions): Promise<unknown>;
-    spawn(command: string, args?: string[], options?: SpawnOptions): Promise<{
-        code: number | null;
-        signal: string | null;
-    }>;
+    spawn(command: string, args?: string[], options?: SpawnOptions): Promise<string>;
     fork(modulePath: string, args?: string[], options?: ForkOptions): Promise<unknown>;
+    getPath(filePath: string): string;
     mkdir(dirPath: string): this;
+    readdir(dirPath: string): Promise<string[]>;
     exists(filePath: string): boolean;
     remove(filePath: string): this;
     removeDir(dirPath: string): this;
     writeFile(filePath: string, content: string | object, { overwrite }?: {
         overwrite?: boolean;
-    }): this;
+    }): FileContent;
     writeJson(filePath: string, content: object): this;
-    getLocalFile(filePath: string): {
-        filepath: string;
+    getLocalFile(targetPath: string): {
+        filePath: string;
         content: string;
     };
     readFile(filePath: string): string;
@@ -49,7 +53,7 @@ export declare class Executor {
         enableSpin?: boolean | undefined;
     }): Spinner;
     getTsConfig(pathname?: string): TsConfigJson;
-    applyTemplate({ basePath, template, scanResult, dict, overwrite, }: {
+    _applyTemplate({ basePath, template, scanResult, dict, overwrite, }: {
         basePath: string;
         template: string;
         scanResult?: AppScanResult | LibScanResult | null;
@@ -57,7 +61,32 @@ export declare class Executor {
             [key: string]: string;
         };
         overwrite?: boolean;
-    }): Promise<void>;
+    }): Promise<FileContent[]>;
+    applyTemplate(options: {
+        basePath: string;
+        template: string;
+        dict?: {
+            [key: string]: string;
+        };
+        overwrite?: boolean;
+    }): Promise<FileContent[]>;
+    getTypeChecker(): TypeChecker;
+    typeCheck(filePath: string): {
+        diagnostics: import("typescript").Diagnostic[];
+        errors: import("typescript").Diagnostic[];
+        warnings: import("typescript").Diagnostic[];
+        message: string;
+    };
+    getLinter(): Linter;
+    lint(filePath: string, { fix, dryRun }?: {
+        fix?: boolean;
+        dryRun?: boolean;
+    }): Promise<{
+        results: import("eslint").ESLint.LintResult[];
+        message: string;
+        errors: import("eslint").Linter.LintMessage[];
+        warnings: import("eslint").Linter.LintMessage[];
+    }>;
 }
 interface ExecutorOptions {
     workspaceRoot: string;
@@ -90,19 +119,19 @@ export declare class WorkspaceExecutor extends Executor {
         add?: boolean;
     }): Promise<void>;
     getScalarConstantFiles(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
     getConstantFiles(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
     getDictionaryFiles(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
     getViewFiles(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
 }
@@ -125,8 +154,8 @@ export declare class SysExecutor extends Executor {
     }, libScanResults?: {
         [key: string]: LibScanResult;
     }): Promise<AppScanResult | LibScanResult>;
-    getLocalFile(filePath: string): {
-        filepath: string;
+    getLocalFile(targetPath: string): {
+        filePath: string;
         content: string;
     };
     getDatabaseModules(): Promise<string[]>;
@@ -136,33 +165,45 @@ export declare class SysExecutor extends Executor {
     getUnitComponents(): Promise<string[]>;
     getTemplateComponents(): Promise<string[]>;
     getViewsSourceCode(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
     getUnitsSourceCode(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
     getTemplatesSourceCode(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
     getScalarConstantFiles(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
     getScalarDictionaryFiles(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
     getConstantFiles(): Promise<{
-        filepath: string;
+        filePath: string;
+        content: string;
+    }[]>;
+    getConstantFilesWithLibs(): Promise<{
+        filePath: string;
         content: string;
     }[]>;
     getDictionaryFiles(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
+    applyTemplate(options: {
+        basePath: string;
+        template: string;
+        dict?: {
+            [key: string]: string;
+        };
+        overwrite?: boolean;
+    }): Promise<FileContent[]>;
     setTsPaths(): this;
 }
 interface AppExecutorOptions {
@@ -207,4 +248,14 @@ export declare class PkgExecutor extends Executor {
         tsconfig?: TsConfigJson;
     }): Promise<PkgScanResult>;
 }
+interface ModuleExecutorOptions {
+    sys: SysExecutor;
+    name: string;
+}
+export declare class ModuleExecutor extends Executor {
+    sys: SysExecutor;
+    emoji: string;
+    constructor({ sys, name }: ModuleExecutorOptions);
+    static from(sysExecutor: SysExecutor, name: string): ModuleExecutor;
+}
 export {};

package/src/guideline.d.ts

@@ -0,0 +1,19 @@
+export interface GuideScan {
+    type: "example" | "source" | "usage" | (string & {});
+    description: string;
+    path: string;
+    filterText?: string;
+    sample?: number;
+}
+export interface GuideUpdate {
+    filePath: string;
+    contents: string[];
+    rules: string[];
+}
+export interface GuideGenerateJson {
+    title: string;
+    description: string;
+    scans: GuideScan[];
+    update: GuideUpdate;
+    page: string;
+}

package/src/index.d.ts

@@ -16,3 +16,5 @@ export * from "./commandDecorators";
 export * from "./aiEditor";
 export * from "./builder";
 export * from "./spinner";
+export * from "./prompter";
+export * from "./guideline";

package/src/linter.d.ts

@@ -0,0 +1,109 @@
+import { ESLint, type Linter as ESLintLinter } from "eslint";
+export declare class Linter {
+    #private;
+    lintRoot: string;
+    constructor(cwdPath: string);
+    lint(filePath: string, { fix, dryRun }?: {
+        fix?: boolean;
+        dryRun?: boolean;
+    }): Promise<{
+        fixed: boolean;
+        output?: string;
+        results: ESLint.LintResult[];
+        errors: ESLintLinter.LintMessage[];
+        warnings: ESLintLinter.LintMessage[];
+    }>;
+    /**
+     * Lint a single file using ESLint
+     * @param filePath - Path to the file to lint
+     * @returns Array of ESLint results
+     */
+    lintFile(filePath: string): Promise<{
+        fixed: boolean;
+        output?: string;
+        results: ESLint.LintResult[];
+        errors: ESLintLinter.LintMessage[];
+        warnings: ESLintLinter.LintMessage[];
+    }>;
+    /**
+     * Format lint results for console output
+     * @param results - Array of ESLint results
+     * @returns Formatted string
+     */
+    formatLintResults(results: ESLint.LintResult[]): string;
+    /**
+     * Get detailed lint information
+     * @param filePath - Path to the file to lint
+     * @returns Object containing detailed lint information
+     */
+    getDetailedLintInfo(filePath: string): Promise<{
+        results: ESLint.LintResult[];
+        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;
+        };
+    }>;
+    /**
+     * Check if a file has lint errors
+     * @param filePath - Path to the file to check
+     * @returns true if there are no errors, false otherwise
+     */
+    hasNoLintErrors(filePath: string): Promise<boolean>;
+    /**
+     * Get only error messages (excluding warnings)
+     * @param filePath - Path to the file to lint
+     * @returns Array of error messages
+     */
+    getErrors(filePath: string): Promise<ESLintLinter.LintMessage[]>;
+    /**
+     * Get only warning messages
+     * @param filePath - Path to the file to lint
+     * @returns Array of warning messages
+     */
+    getWarnings(filePath: string): Promise<ESLintLinter.LintMessage[]>;
+    /**
+     * 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
+     */
+    fixFile(filePath: string, dryRun?: boolean): Promise<{
+        fixed: boolean;
+        output?: string;
+        results: ESLint.LintResult[];
+        errors: ESLintLinter.LintMessage[];
+        warnings: ESLintLinter.LintMessage[];
+    }>;
+    /**
+     * Get ESLint configuration for a file
+     * @param filePath - Path to the file
+     * @returns ESLint configuration object
+     */
+    getConfigForFile(filePath: string): Promise<unknown>;
+    /**
+     * 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
+     */
+    getProblematicRules(filePath: string): Promise<Record<string, number>>;
+}

package/src/prompter.d.ts

@@ -0,0 +1,13 @@
+import type { GuideGenerateJson } from "./guideline";
+interface FileUpdateRequestProps {
+    context: string;
+    request: string;
+}
+export declare class Prompter {
+    static selectGuideline(): Promise<string>;
+    static getGuideJson(guideName: string): Promise<GuideGenerateJson>;
+    static getInstruction(guideName: string): Promise<string>;
+    makeTsFileUpdatePrompt({ context, request }: FileUpdateRequestProps): Promise<string>;
+    getDocumentation(guideName: string): Promise<string>;
+}
+export {};

package/src/typeChecker.d.ts

@@ -0,0 +1,49 @@
+import * as ts from "typescript";
+import type { Executor } from "./executors";
+export declare class TypeChecker {
+    #private;
+    readonly configPath: string;
+    readonly configFile: {
+        config?: any;
+        error?: ts.Diagnostic;
+    };
+    readonly config: ts.ParsedCommandLine;
+    constructor(executor: Executor);
+    /**
+     * Type-check a single TypeScript file
+     * @param filePath - Path to the TypeScript file to check
+     * @returns Array of diagnostic messages
+     */
+    check(filePath: string): {
+        diagnostics: ts.Diagnostic[];
+        errors: ts.Diagnostic[];
+        warnings: ts.Diagnostic[];
+    };
+    /**
+     * Format diagnostics for console output
+     * @param diagnostics - Array of TypeScript diagnostics
+     * @returns Formatted string
+     */
+    formatDiagnostics(diagnostics: ts.Diagnostic[]): string;
+    /**
+     * Get detailed diagnostic information with code snippet
+     * @param filePath - Path to the TypeScript file to check
+     * @returns Object containing diagnostics and detailed information
+     */
+    getDetailedDiagnostics(filePath: string): {
+        diagnostics: ts.Diagnostic[];
+        details: {
+            line: number;
+            column: number;
+            message: string;
+            code: number;
+            codeSnippet?: string;
+        }[];
+    };
+    /**
+     * Check if a file has type errors
+     * @param filePath - Path to the TypeScript file to check
+     * @returns true if there are no type errors, false otherwise
+     */
+    hasNoTypeErrors(filePath: string): boolean;
+}

package/src/types.d.ts

@@ -24,3 +24,7 @@ export interface TsConfigJson {
         path: string;
     }[];
 }
+export interface FileContent {
+    filePath: string;
+    content: string;
+}

package/src/uploadRelease.d.ts

@@ -1,4 +1,4 @@
-export declare const uploadRelease: (projectName: string, { workspaceRoot, environment, buildNum, platformVersion, local, }: {
+export declare const uploadRelease: (appName: string, { workspaceRoot, environment, buildNum, platformVersion, local, }: {
     workspaceRoot: string;
     environment: string;
     buildNum: number;