@codenotch/codenotch.cli 1.0.33 → 1.0.35

package/src/utils/ConsoleUtils.ts

@@ -1,22 +0,0 @@
-import chalk from "chalk";
-
-export default abstract class ConsoleUtils {
-    static check(text: string){
-        console.log(`${chalk.green('✓')} ${text}`);
-    }
-    static checkWarning(text: string){
-        console.log(`${chalk.yellow('✓')} ${text}`);
-    }
-    
-
-
-    static proposeCommand(question: string, command: string){
-        let data = JSON.stringify({question, command});
-        return `\u001b_Gcodenotchcli:proposeCommand:${data}\u001b\\`;
-    }
-
-    static proposeOpenUri(question: string, uri: string){
-        let data = JSON.stringify({question, uri});
-        return `\u001b_Gcodenotchcli:proposeOpenUri:${data}\u001b\\`;
-    }
-}

package/src/utils/FileUtils.ts

@@ -1,266 +0,0 @@
-import fs from 'fs';
-import StringUtils from './StringUtils';
-import path from 'path';
-import fse, { CopyOptions, MoveOptions } from 'fs-extra';
-import { platform } from 'os';
-import AdmZip from 'adm-zip';
-
-export default abstract class FileUtils {
-
-
-    public static async zipFolder(targetPath: string, zipFilePath: string) {
-        try {
-            targetPath = FileUtils.normalize(targetPath);
-            zipFilePath = FileUtils.normalize(zipFilePath);
-
-            // Ensure the directory for the zip file exists
-            const zipDir = path.dirname(zipFilePath);
-            if (!fs.existsSync(zipDir)) {
-                fs.mkdirSync(zipDir, { recursive: true });
-            }
-
-            const zip = new AdmZip();
-
-            const stats = fs.lstatSync(targetPath);
-            if (stats.isDirectory()) {
-                zip.addLocalFolder(targetPath, '');
-            } else {
-                zip.addLocalFile(targetPath);
-            }
-
-            zip.writeZip(zipFilePath);
-            return true;
-        } catch (e) {
-            console.error(`Error zipping folder "${targetPath}":`, e);
-            return false;
-        }
-    }
-
-    public static slash() {
-        return platform() === 'win32' ? '\\' : '/';
-    }
-
-    static normalize(path?: string): string {
-        if (path === undefined)
-            return '';
-
-        if (path.startsWith("http")) {
-            return path.replaceAll('\\', '/');
-        }
-
-        let os = platform();
-        if (os === 'win32') {
-            path = path.replaceAll("/", '\\');
-        }
-        else {
-            path = path.replaceAll('\\', '/');
-        }
-        return path;
-    }
-
-    public static async exists(filePath: string): Promise<boolean> {
-        filePath = FileUtils.normalize(filePath);
-        try {
-            await fs.promises.access(filePath, fs.constants.F_OK);
-            return true;
-        } catch (e) {
-            return false;
-        }
-    }
-
-    public static async readFileAsync(filePath: string): Promise<string> {
-        filePath = FileUtils.normalize(filePath);
-        
-        return await fs.promises.readFile(filePath, { encoding: "utf-8" });
-    }
-
-    public static async readJsonFileAsync<T>(filePath: string): Promise<T | null> {
-        filePath = FileUtils.normalize(filePath);
-        
-        const content = await fs.promises.readFile(filePath, { encoding: "utf-8" });
-        if(!content || content.trim() === '') {
-            return null;
-        }
-
-        return JSON.parse(content) as T;
-    }
-
-    public static writeFileSync(filePath: string, content: string): boolean {
-        
-        try {
-            filePath = StringUtils.normalizePath(filePath);
-            let folder = path.dirname(filePath);
-            if (!fs!.existsSync(folder)) {
-                fs!.mkdirSync(folder, { recursive: true });
-            }
-            fs!.writeFileSync(filePath, content, { encoding: "utf-8" });
-            return true;
-        }
-        catch (e) {
-            console.error(`Error writing file "${filePath}":`, e);
-            return false;
-        }
-    }
-
-    public static async copyFolder(folderPath: string, copyInto: string, ignoreFolders: string[] = []): Promise<void> {
-        folderPath = FileUtils.normalize(folderPath);
-        copyInto = FileUtils.normalize(copyInto);
-
-        if (fse === undefined || path === undefined) {
-            return;
-        }
-
-        if (!fse.existsSync(copyInto)) {
-            // Create destination folder
-            fse.mkdirSync(copyInto, { recursive: true });
-        }
-
-        let options: CopyOptions = {
-            recursive: true,
-            overwrite: true,
-            filter: (path) => !ignoreFolders.some(folder => path.includes(folder)) // ignore specified folders
-        }
-
-        // if destination is a subdirectory of the copies folder we need to handle things differently
-        if (copyInto.includes(folderPath)) {
-
-            let destFolderName = path.basename(copyInto);
-
-            // We cannot use copy directly on the root folder because it won't work "to" is a subdirectory of the root folder
-            let files = await fse.readdir(folderPath);
-
-            for (let f of files) {
-
-                // Ignore destination if it is a subdirectory
-                if (f === destFolderName)
-                    continue;
-
-                // Or if it belongs to the ignored files/folders
-                if (ignoreFolders.some(folder => f === folder)) // ignore specified folders
-                    continue;
-
-                let from = path.join(folderPath, f);
-                let to = path.join(copyInto, f);
-
-                await fse.copy(from, to, options);
-            }
-
-        }
-        else {
-            await fse.copy(folderPath, copyInto, options);
-        }
-    }
-
-    public static async moveFolder(folderPath: string, moveInto: string, ignoreFolders: string[] = []): Promise<void> {
-        folderPath = FileUtils.normalize(folderPath);
-        moveInto = FileUtils.normalize(moveInto);
-
-        if (fse === undefined || path === undefined) {
-            return;
-        }
-
-        if (!fse.existsSync(moveInto)) {
-            // Create destination folder
-            fse.mkdirSync(moveInto, { recursive: true });
-        }
-
-        let options: MoveOptions = {
-            overwrite: true
-        }
-
-        // if destination is a subdirectory of the copies folder we need to handle things differently
-        if (moveInto.includes(folderPath)) {
-
-            let destFolderName = path.basename(moveInto);
-
-            // We cannot use copy directly on the root folder because it won't work "to" is a subdirectory of the root folder
-            let files = await fse.readdir(folderPath);
-
-            for (let f of files) {
-
-                // Ignore destination if it is a subdirectory
-                if (f === destFolderName)
-                    continue;
-
-                // Or if it belongs to the ignored files/folders
-                if (ignoreFolders.some(folder => f === folder)) // ignore specified folders
-                    continue;
-
-                let from = path.join(folderPath, f);
-                let to = path.join(moveInto, f);
-
-                await fse.move(from, to, options);
-            }
-
-        }
-        else {
-            await fse.move(folderPath, moveInto, options);
-        }
-    }
-
-
-    public static delete(path: string) {
-        path = StringUtils.normalizePath(path);
-        if (fs.existsSync(path)) {
-            if (fs.lstatSync(path).isDirectory()) {
-                fs.rmSync(path, { recursive: true, force: true });
-            }
-            else {
-                fs.unlinkSync(path);
-            }
-        }
-    }
-
-    public static getAllFilesFromPath(path: string, ignoreFolders: string[] = []): string[] {
-
-        try {
-            path = StringUtils.normalizePath(path);
-            let isDirectory = fs.lstatSync(path).isDirectory();
-            if (isDirectory) {
-
-                if(ignoreFolders && ignoreFolders.some(c => path.endsWith(`\\${c}`) || path.endsWith(`/${c}`))){
-                    return [];
-                }
-                
-                return this.getAllFiles(path, ignoreFolders);
-            }
-            else {
-                return [path];
-            }
-        }
-        catch {
-            return [];
-        }
-    }
-
-    private static getAllFiles(path: string, ignoreFolders: string[] = [], arrayOfFiles?: string[], level?: number): string[] {
-
-        path = StringUtils.normalizePath(path);
-
-        if (ignoreFolders.some(c => path.endsWith(`\\${c}`) || path.endsWith(`/${c}`))) {
-            return [];
-        }
-
-        let files = fs.readdirSync(path, { withFileTypes: true });
-
-        arrayOfFiles = arrayOfFiles ? arrayOfFiles : [];
-
-        for (let i = 0; i < files.length; i++) {
-            let file = files[i];
-            let nextPath = StringUtils.normalizePath(`${path}\\${file.name}`);
-            if (file.isDirectory()) {
-                if (ignoreFolders.some(c => nextPath.endsWith(`\\${c}`) || nextPath.endsWith(`/${c}`))) {
-                    continue;
-                }
-                else {
-                    arrayOfFiles = this.getAllFiles(nextPath, ignoreFolders, arrayOfFiles, (level ?? 0) + 1);
-                }
-            } else {
-
-                arrayOfFiles!.push(nextPath);
-            }
-        }
-
-        return arrayOfFiles
-    }
-}

package/src/utils/GitHubAuthUtils.ts

@@ -1,83 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import os from "node:os";
-import readline from "node:readline";
-import chalk from "chalk";
-import { createOAuthDeviceAuth } from "@octokit/auth-oauth-device";
-import { OsUtils } from "./OsUtils";
-import { deletePassword, getPassword, setPassword } from "cross-keychain";
-
-const SERVICE_NAME = "codenotch-cli";
-const ACCOUNT_NAME = "github-oauth-token";
-
-/**
- * Handles GitHub authentication for the CLI.
- */
-export default abstract class GitHubAuthUtils {
-
-    /**
-     * Returns a valid GitHub token, prompting the user interactively if needed.
-     * @param forceReauth  When true, skip cache and always prompt again.
-     */
-    static async getToken(forceReauth = false): Promise<string> {
-
-        // Use PAT if provided via environment variable (e.g. for CI or advanced users)
-        if (process.env.GITHUB_TOKEN) {
-            return process.env.GITHUB_TOKEN;
-        }
-
-        // Try to get token from cache (keychain)
-        try {
-            const cachedToken = await getPassword(SERVICE_NAME, ACCOUNT_NAME);
-            if (cachedToken) {
-                // Do a quick fetch to GitHub to ensure the token hasn't been revoked
-                const response = await fetch("https://api.github.com/user", {
-                    headers: {
-                        Authorization: `Bearer ${cachedToken}`
-                    },
-                });
-                if (response.ok) {
-                    return cachedToken;
-                }
-                // Token is invalid/revoked — delete it and fall through to re-auth
-                await deletePassword(SERVICE_NAME, ACCOUNT_NAME).catch(() => {});
-            }
-        } catch (err: any) {
-            // If keychain reading fails, silently fall back to running the login flow
-        }
-
-        const auth = createOAuthDeviceAuth({
-            clientType: "oauth-app",
-            clientId: "Ov23liEBS0dxtgGbq4K9",
-            scopes: ["repo"],                 
-            onVerification(verification) {
-            console.log("Open your browser at:");
-            console.log(verification.verification_uri);
-            OsUtils.openInBrowser(verification.verification_uri);
-            console.log(`\nEnter code: ${verification.user_code}`);
-            },
-        });
-
-        const tokenAuthentication = await auth({ type: "oauth" });
-  
-        const token = tokenAuthentication.token;
-
-        try {
-            await setPassword(SERVICE_NAME, ACCOUNT_NAME, token);
-            console.log("Login successful! Session saved securely.");
-        } catch (err: any) {
-            console.error("Warning: Could not save token to system keychain.", err.message);
-        }
-
-        return token;
-    }
-
-    async logout() {
-        try {
-            await deletePassword(SERVICE_NAME, ACCOUNT_NAME);
-            console.log("Logged out successfully. Secure token deleted.");
-        } catch (err: any) {
-            console.error("Failed to clear local token:", err.message);
-        }
-    }
-}

package/src/utils/I18nUtils.ts

@@ -1,58 +0,0 @@
-import { readFileSync } from "fs";
-import FileUtils from "./FileUtils";
-import Papa from "papaparse";
-
-export default abstract class I18nUtils {
-
-
-    public static async getAllI18nFiles(folderPath: string) {
-        let files = FileUtils.getAllFilesFromPath(folderPath, ['.codenotch', 'node_modules', 'dist', 'build']).filter(c => c.endsWith('.i18n.csv'));
-        let allLines: { key: string, values: { lang: string, value: string }[] }[] = [];
-        for (let file of files) {
-
-            // parse
-            let config = { header: true };
-            let content = readFileSync(file, { encoding: "utf-8" });
-            let lines = Papa.parse<{ [lang: string]: string }>(content, config).data;
-            if (lines.length === 0)
-                continue;
-
-            // Ignore import line
-            lines = lines.slice(1);
-
-            for(let line of lines){
-                let masterLine = allLines.find(c => c.key === line.key);
-                if(masterLine === undefined){
-                    masterLine = {
-                        key: line.key,
-                        values: []
-                    };
-                    allLines.push(masterLine);
-                }
-                
-                let langs = Object.keys(line).filter(c => c !== 'key');
-                for(let lang of langs){
-                    let value = line[lang];
-                    if(typeof value === 'string' && value.trim() !== ''){
-                        if(masterLine.values.find(c => c.lang === lang) === undefined){
-                            masterLine.values.push({
-                                lang,
-                                value
-                            });
-                        }
-                        else{
-                            // Duplicate value for language 'lang'
-                        }
-                    }
-                }
-            }
-        }
-        for(let line of allLines){
-            line.values = line.values.sort((a, b) => a.lang.localeCompare(b.lang));
-        }
-        allLines = allLines.sort((a, b) => a.key.localeCompare(b.key));
-        return allLines;
-    }
-
-
-}