@acristhian1411/notecli 1.0.0

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@acristhian1411/notecli",
+  "version": "1.0.0",
+  "description": "",
+  "type": "module",
+  "bin": {
+    "notecli": "./src/cli.js"
+  },
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "dev": "node ./src/cli.js",
+    "lint": "eslint . --ext .js",
+    "bundle": "esbuild ./src/cli.js --bundle --platform=node --target=node18 --outfile=dist/notecli.js",
+    "build": "pkg . --output notecli",
+    "build:win": "nexe ./src/cli.js -t windows-x64-22.16.0 -o  dist/notecli-win.exe --build",
+    "build:linux": "nexe ./src/cli.js -t linux-x64-22.16.0 -o dist/notecli-linux --build",
+    "build:winp": "pkg dist/notecli.js --targets node18-win-x64 --output dist/notecli-win.exe --debug",
+    "build:linuxp": "pkg dist/notecli.js --targets node18-linux-x64 --output dist/notecli-linux --debug"
+  },
+  "pkg": {
+    "scripts": "src/**/*.js",
+    "targets": [
+      "node18-win-x64"
+    ]
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.11.0",
+  "devDependencies": {
+    "esbuild": "^0.27.3",
+    "nexe": "5.0.0-beta.4",
+    "pkg": "^5.8.1"
+  },
+  "dependencies": {
+    "archiver": "^7.0.1",
+    "chalk": "^5.6.2",
+    "cli-highlight": "^2.1.11",
+    "cli-table3": "^0.6.5",
+    "commander": "^14.0.3",
+    "conf": "^15.1.0",
+    "inquirer": "^13.3.0",
+    "marked": "^17.0.3",
+    "marked-terminal": "^7.3.0"
+  }
+}

package/src/cli.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+/**
+ * CLI principal de NoteApp.
+ * Se encarga únicamente de registrar comandos y delegar ejecución.
+ */
+
+import { Command } from "commander";
+import createCommand from "./commands/create.js";
+import listCommand from "./commands/list.js";
+import viewCommand from "./commands/view.js";
+import editCommand from "./commands/edit.js";
+import searchCommand from "./commands/search.js";
+import exportCommand from "./commands/export.js";
+// import statsCommand from "./commands/stats.js";
+
+const program = new Command();
+
+program
+  .name("notecli")
+  .description("CLI para gestión de notas Markdown")
+  .version("1.0.0");
+
+createCommand(program);
+listCommand(program);
+viewCommand(program);
+editCommand(program);
+searchCommand(program);
+exportCommand(program);
+// statsCommand(program);
+
+program.parse();

package/src/commands/create.js

@@ -0,0 +1,29 @@
+/**
+ * Registra el comando `create`.
+ * @param {Command} program instancia principal de commander
+ */
+
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+
+export default function createCommand(program) {
+  program
+    .command("create <name>")
+    .description("Crea una nueva nota Markdown")
+    .action(async (name) => {
+      try {
+        const notesDir = path.join(os.homedir(), ".noteapp");
+
+        await fs.mkdir(notesDir, { recursive: true });
+
+        const filePath = path.join(notesDir, `${name}.md`);
+
+        await fs.writeFile(filePath, `# ${name}\n\n`);
+
+        console.log(`Nota creada: ${filePath}`);
+      } catch (error) {
+        console.error("Error creando nota:", error.message);
+      }
+    });
+}

package/src/commands/edit.js

@@ -0,0 +1,77 @@
+/**
+ * Comando `edit`
+ * Abre una nota existente en el editor configurado.
+ */
+
+import chalk from "chalk";
+import { spawn } from "child_process";
+import { getNotePath, noteExists } from "../core/notes.service.js";
+import { getConfig } from "../core/config.service.js";
+
+/**
+ * Abre el archivo en el editor configurado.
+ * @param {string} filePath Ruta completa del archivo
+ * @param {string} editor Nombre del editor
+ * @returns {Promise<void>}
+ */
+function openInEditor(filePath, editor) {
+  return new Promise((resolve, reject) => {
+    const editorProcess = spawn(editor, [filePath], {
+      stdio: "inherit",
+      shell: true
+    });
+
+    editorProcess.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`El editor terminó con código ${code}`));
+      }
+    });
+
+    editorProcess.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Registra el comando edit.
+ * @param {Command} program
+ */
+export default function editCommand(program) {
+  program
+    .command("edit <name>")
+    .description("Abre una nota existente en el editor")
+    .option("-e, --editor <editor>", "Editor a utilizar (por defecto: configurado)")
+    .action(async (name, options) => {
+      try {
+        // Verificar que la nota existe
+        const exists = await noteExists(name);
+        if (!exists) {
+          console.error(
+            chalk.red(`La nota "${name}" no existe. Usa 'noteapp create ${name}' para crearla.`)
+          );
+          process.exit(1);
+        }
+
+        // Obtener el editor configurado o usar el de las opciones
+        const config = getConfig();
+        const editor = options.editor || config.editor || process.env.EDITOR || "nano";
+        
+        const filePath = getNotePath(name);
+        
+        console.log(chalk.blue(`Abriendo "${name}.md" en ${editor}...`));
+        
+        await openInEditor(filePath, editor);
+        
+        console.log(chalk.green(`✓ Nota "${name}" editada exitosamente.`));
+      } catch (error) {
+        console.error(
+          chalk.red(`Error al editar la nota "${name}":`),
+          error.message
+        );
+        process.exit(1);
+      }
+    });
+}

package/src/commands/export.js

@@ -0,0 +1,191 @@
+/**
+ * Comando `export`
+ * Menú interactivo para selección múltiple y exportación (MD/ZIP).
+ */
+
+import chalk from "chalk";
+import inquirer from "inquirer";
+import fs from "fs/promises";
+import fsSync from "fs";
+import path from "path";
+import os from "os";
+import archiver from "archiver";
+import { getAllNotes, getNotePath } from "../core/notes.service.js";
+
+/**
+ * Detecta la carpeta de descargas del usuario.
+ * @returns {string}
+ */
+function getDownloadsFolder() {
+  const homeDir = os.homedir();
+  
+  // Intenta diferentes rutas según el sistema operativo
+  const possiblePaths = [
+    path.join(homeDir, "Downloads"),
+    path.join(homeDir, "Descargas"),
+    path.join(homeDir, "downloads"),
+    homeDir // Fallback al home si no encuentra Downloads
+  ];
+  
+  for (const downloadPath of possiblePaths) {
+    try {
+      if (fsSync.existsSync(downloadPath)) {
+        return downloadPath;
+      }
+    } catch {
+      continue;
+    }
+  }
+  
+  return homeDir;
+}
+
+/**
+ * Copia un archivo único al destino.
+ * @param {string} sourcePath Ruta del archivo origen
+ * @param {string} destPath Ruta del destino
+ */
+async function copyFile(sourcePath, destPath) {
+  await fs.copyFile(sourcePath, destPath);
+}
+
+/**
+ * Crea un archivo ZIP con las notas seleccionadas.
+ * @param {Array<string>} notePaths Rutas de las notas a comprimir
+ * @param {string} outputPath Ruta del archivo ZIP de salida
+ * @returns {Promise<void>}
+ */
+function createZip(notePaths, outputPath) {
+  return new Promise((resolve, reject) => {
+    const output = fsSync.createWriteStream(outputPath);
+    const archive = archiver("zip", {
+      zlib: { level: 9 } // Máxima compresión
+    });
+    
+    output.on("close", () => {
+      resolve();
+    });
+    
+    archive.on("error", (err) => {
+      reject(err);
+    });
+    
+    archive.on("warning", (err) => {
+      if (err.code === "ENOENT") {
+        console.warn(chalk.yellow(`Advertencia: ${err.message}`));
+      } else {
+        reject(err);
+      }
+    });
+    
+    archive.pipe(output);
+    
+    // Agregar cada archivo al ZIP
+    notePaths.forEach((notePath) => {
+      const fileName = path.basename(notePath);
+      archive.file(notePath, { name: fileName });
+    });
+    
+    archive.finalize();
+  });
+}
+
+/**
+ * Formatea el tamaño de archivo en bytes a formato legible.
+ * @param {number} bytes
+ * @returns {string}
+ */
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+
+/**
+ * Registra el comando export.
+ * @param {Command} program
+ */
+export default function exportCommand(program) {
+  program
+    .command("export")
+    .description("Exporta notas a la carpeta de Descargas")
+    .option("-o, --output <path>", "Carpeta de destino personalizada")
+    .action(async (options) => {
+      try {
+        const notes = await getAllNotes();
+        
+        if (notes.length === 0) {
+          console.log(chalk.yellow("No hay notas disponibles para exportar."));
+          return;
+        }
+        
+        // Menú interactivo para seleccionar notas
+        const answers = await inquirer.prompt([
+          {
+            type: "checkbox",
+            name: "selectedNotes",
+            message: "Selecciona las notas a exportar:",
+            choices: notes.map((note) => ({
+              name: `${note.name}.md ${chalk.gray(`(${formatBytes(note.size)})`)}`,
+              value: note.name,
+              checked: false
+            })),
+            validate: (answer) => {
+              if (answer.length === 0) {
+                return "Debes seleccionar al menos una nota.";
+              }
+              return true;
+            }
+          }
+        ]);
+        
+        const selectedNotes = answers.selectedNotes;
+        
+        if (selectedNotes.length === 0) {
+          console.log(chalk.yellow("No se seleccionó ninguna nota."));
+          return;
+        }
+        
+        // Determinar carpeta de destino
+        const outputDir = options.output || getDownloadsFolder();
+        
+        console.log(chalk.blue(`\nExportando ${selectedNotes.length} nota(s)...\n`));
+        
+        if (selectedNotes.length === 1) {
+          // Un solo archivo: copia directa
+          const noteName = selectedNotes[0];
+          const sourcePath = getNotePath(noteName);
+          const destPath = path.join(outputDir, `${noteName}.md`);
+          
+          await copyFile(sourcePath, destPath);
+          
+          console.log(chalk.green(`✓ Nota exportada: ${destPath}`));
+        } else {
+          // Múltiples archivos: crear ZIP
+          const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+          const zipFileName = `notes_export_${timestamp}.zip`;
+          const zipPath = path.join(outputDir, zipFileName);
+          
+          const notePaths = selectedNotes.map((name) => getNotePath(name));
+          
+          console.log(chalk.blue("Comprimiendo archivos..."));
+          
+          await createZip(notePaths, zipPath);
+          
+          // Obtener tamaño del ZIP creado
+          const stats = await fs.stat(zipPath);
+          
+          console.log(chalk.green(`\n✓ ZIP creado: ${zipPath}`));
+          console.log(chalk.gray(`  Tamaño: ${formatBytes(stats.size)}`));
+          console.log(chalk.gray(`  Notas incluidas: ${selectedNotes.length}`));
+        }
+        
+        console.log(chalk.blue(`\n✓ Exportación completada exitosamente.`));
+      } catch (error) {
+        console.error(chalk.red("Error durante la exportación:"), error.message);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/list.js

@@ -0,0 +1,48 @@
+/**
+ * Comando `list`
+ * Muestra una tabla con nombre, fecha de modificación y tamaño.
+ */
+
+import Table from "cli-table3";
+import chalk from "chalk";
+import { getAllNotes } from "../core/notes.service.js";
+
+/**
+ * Registra el comando list en commander.
+ * @param {Command} program
+ */
+export default function listCommand(program) {
+  program
+    .command("list")
+    .description("Lista todas las notas disponibles")
+    .action(async () => {
+      try {
+        const notes = await getAllNotes();
+
+        if (!notes.length) {
+          console.log(chalk.yellow("No hay notas creadas aún."));
+          return;
+        }
+
+        const table = new Table({
+          head: [
+            chalk.cyan("Nombre"),
+            chalk.cyan("Última Modificación"),
+            chalk.cyan("Tamaño (bytes)")
+          ]
+        });
+
+        notes.forEach((note) => {
+          table.push([
+            note.name,
+            note.mtime.toLocaleString(),
+            note.size
+          ]);
+        });
+
+        console.log(table.toString());
+      } catch (error) {
+        console.error(chalk.red("Error listando notas:"), error.message);
+      }
+    });
+}

package/src/commands/search.js

@@ -0,0 +1,132 @@
+/**
+ * Comando `search`
+ * Realiza búsqueda de texto completo (full-text search) en todas las notas.
+ */
+
+import chalk from "chalk";
+import { getAllNotes, getNoteContent } from "../core/notes.service.js";
+
+/**
+ * Obtiene el contexto alrededor de una coincidencia.
+ * @param {string} content Contenido completo
+ * @param {number} index Índice de la coincidencia
+ * @param {number} contextLength Cantidad de caracteres de contexto
+ * @returns {string}
+ */
+function getContext(content, index, contextLength = 50) {
+  const start = Math.max(0, index - contextLength);
+  const end = Math.min(content.length, index + contextLength);
+  
+  let context = content.slice(start, end);
+  
+  if (start > 0) context = "..." + context;
+  if (end < content.length) context = context + "...";
+  
+  return context;
+}
+
+/**
+ * Busca una query en el contenido y retorna las coincidencias con contexto.
+ * @param {string} content Contenido de la nota
+ * @param {string} query Texto a buscar
+ * @returns {Array<{line: number, context: string, index: number}>}
+ */
+function findMatches(content, query) {
+  const matches = [];
+  const lowerContent = content.toLowerCase();
+  const lowerQuery = query.toLowerCase();
+  
+  let index = lowerContent.indexOf(lowerQuery);
+  
+  while (index !== -1) {
+    // Calcular número de línea
+    const beforeMatch = content.slice(0, index);
+    const line = beforeMatch.split("\n").length;
+    
+    // Obtener contexto
+    const context = getContext(content, index, 60);
+    
+    matches.push({ line, context, index });
+    
+    // Buscar siguiente coincidencia
+    index = lowerContent.indexOf(lowerQuery, index + 1);
+  }
+  
+  return matches;
+}
+
+/**
+ * Resalta la query en el texto.
+ * @param {string} text Texto donde resaltar
+ * @param {string} query Texto a resaltar
+ * @returns {string}
+ */
+function highlightQuery(text, query) {
+  const regex = new RegExp(`(${query})`, "gi");
+  return text.replace(regex, chalk.bgYellow.black("$1"));
+}
+
+/**
+ * Registra el comando search.
+ * @param {Command} program
+ */
+export default function searchCommand(program) {
+  program
+    .command("search <query>")
+    .description("Busca texto en todas las notas")
+    .option("-l, --limit <number>", "Limitar resultados por nota", "3")
+    .action(async (query, options) => {
+      try {
+        const notes = await getAllNotes();
+        
+        if (notes.length === 0) {
+          console.log(chalk.yellow("No hay notas disponibles para buscar."));
+          return;
+        }
+        
+        console.log(chalk.blue(`\nBuscando "${query}" en ${notes.length} nota(s)...\n`));
+        
+        let totalMatches = 0;
+        const limit = parseInt(options.limit, 10);
+        
+        for (const note of notes) {
+          try {
+            const content = await getNoteContent(note.name);
+            const matches = findMatches(content, query);
+            
+            if (matches.length > 0) {
+              totalMatches += matches.length;
+              
+              console.log(chalk.green.bold(`📄 ${note.name}.md`) + chalk.gray(` (${matches.length} coincidencia(s))`));
+              
+              // Limitar resultados mostrados por nota
+              const displayMatches = matches.slice(0, limit);
+              
+              displayMatches.forEach((match) => {
+                const highlighted = highlightQuery(match.context, query);
+                console.log(chalk.gray(`   Línea ${match.line}: `) + highlighted);
+              });
+              
+              if (matches.length > limit) {
+                console.log(chalk.gray(`   ... y ${matches.length - limit} coincidencia(s) más`));
+              }
+              
+              console.log(); // Línea en blanco
+            }
+          } catch (error) {
+            // Ignorar errores de lectura individual y continuar
+            console.error(chalk.red(`   Error leyendo ${note.name}: ${error.message}`));
+          }
+        }
+        
+        if (totalMatches === 0) {
+          console.log(chalk.yellow(`No se encontraron coincidencias para "${query}".`));
+        } else {
+          console.log(chalk.blue(`\n✓ Total: ${totalMatches} coincidencia(s) encontrada(s).`));
+        }
+      } catch (error) {
+        console.error(chalk.red("Error durante la búsqueda:"), error.message);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/view.js

@@ -0,0 +1,50 @@
+/**
+ * Comando `view`
+ * Renderiza una nota Markdown en la terminal usando marked + marked-terminal.
+ */
+
+import chalk from "chalk";
+import { marked, Renderer} from "marked";
+import TerminalRenderer, {markedTerminal} from "marked-terminal";
+import { highlight } from "cli-highlight";
+import { getNoteContent } from "../core/notes.service.js";
+import { CommanderError } from "commander";
+
+/**
+ * Configura marked para usar el renderer de terminal.
+ */
+marked.use(markedTerminal());
+marked.use({ renderer: {
+    code(code,lang){
+      const language = lang || "plaintext";
+      const highlighted = highlight(code, { language, ignoreIllegals: true });
+      return `\n${highlighted}\n`;
+    }
+  }
+});
+
+
+/**
+ * Registra el comando view.
+ * @param {Command} program
+ */
+export default function viewCommand(program) {
+  program
+    .command("view <name>")
+    .description("Muestra el contenido renderizado de una nota")
+    .action(async (name) => {
+      try {
+        const content = await getNoteContent(name);
+
+        const rendered = marked.parse(content);
+        
+
+        console.log(rendered);
+      } catch (error) {
+        console.error(
+          chalk.red(`No se pudo abrir la nota "${name}".`),
+          error.message
+        );
+      }
+    });
+}

package/src/core/config.service.js

@@ -0,0 +1,34 @@
+/**
+ * Servicio de configuración persistente usando `conf`.
+ * Permite almacenar ruta personalizada de notas y editor.
+ */
+
+import Conf from "conf";
+import os from "os";
+import path from "path";
+
+const config = new Conf({
+  projectName: "noteapp",
+  defaults: {
+    notesDir: null,
+    editor: "code"
+  }
+});
+
+export function getConfig() {
+  return config.store;
+}
+
+export function setConfig(key, value) {
+  config.set(key, value);
+}
+
+export function resolveNotesDir() {
+  const customDir = config.get("notesDir");
+
+  if (customDir && typeof customDir === "string") {
+    return path.resolve(customDir);
+  }
+
+  return path.join(os.homedir(), ".noteapp");
+}

package/src/core/notes.service.js

@@ -0,0 +1,75 @@
+/**
+ * Servicio para gestión de notas en el sistema de archivos.
+ * Encapsula toda la lógica de lectura y metadata.
+ */
+
+import fs from "fs/promises";
+import path from "path";
+import { resolveNotesDir } from "./config.service.js";
+
+/**
+ * Obtiene todas las notas .md disponibles.
+ * @returns {Promise<Array<{ name: string, path: string, size: number, mtime: Date }>>}
+ */
+export async function getAllNotes() {
+  const notesDir = resolveNotesDir();
+
+  await fs.mkdir(notesDir, { recursive: true });
+
+  const files = await fs.readdir(notesDir);
+
+  const mdFiles = files.filter((file) => file.endsWith(".md"));
+
+  const notes = await Promise.all(
+    mdFiles.map(async (file) => {
+      const filePath = path.join(notesDir, file);
+      const stats = await fs.stat(filePath);
+
+      return {
+        name: file.replace(".md", ""),
+        path: filePath,
+        size: stats.size,
+        mtime: stats.mtime
+      };
+    })
+  );
+
+  return notes;
+}
+
+/**
+ * Obtiene el contenido de una nota específica.
+ * @param {string} name Nombre sin extensión
+ * @returns {Promise<string>}
+ */
+export async function getNoteContent(name) {
+  const notesDir = resolveNotesDir();
+  const filePath = path.join(notesDir, `${name}.md`);
+
+  return fs.readFile(filePath, "utf-8");
+}
+
+/**
+ * Obtiene la ruta completa de una nota.
+ * @param {string} name Nombre sin extensión
+ * @returns {string}
+ */
+export function getNotePath(name) {
+  const notesDir = resolveNotesDir();
+  return path.join(notesDir, `${name}.md`);
+}
+
+/**
+ * Verifica si una nota existe.
+ * @param {string} name Nombre sin extensión
+ * @returns {Promise<boolean>}
+ */
+export async function noteExists(name) {
+  try {
+    const filePath = getNotePath(name);
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}