cpoach.sh 0.2.4 → 0.3.0

package/index.js

@@ -1,7 +1,170 @@
+#!/usr/bin/env node
 const fs   = require('fs');
+const os   = require('os');
 const path = require('path');
+const cp   = require('child_process');
+const readline = require('readline');
 
+const PRE = '# 🍳 ';
 
+
+
+
+//#region UTILS
+// Escape special characters in a string for use in a regular expression.
+function escapeRegExp(pat) {
+  return pat.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+
+// Read a text file synchronously and normalize line endings to LF.
+function readTextFileSync(pth) {
+  const data = fs.readFileSync(pth, 'utf8');
+  return data.replace(/\r?\n|\r/g, '\n');
+}
+
+
+// Write a text file synchronously and normalize line endings to LF.
+function writeTextFileSync(pth, text) {
+  const data = text.replace(/\r?\n|\r/g, os.EOL);
+  fs.writeFileSync(pth, data, 'utf8');
+}
+
+
+// Read a JSON file synchronously and parse it.
+function readJSONFileSync(pth) {
+  const text = readTextFileSync(pth);
+  return JSON.parse(text);
+}
+
+
+// Write a JSON file synchronously and stringify it with indentation.
+function writeJSONFileSync(pth, obj) {
+  const text = JSON.stringify(obj, null, 2) + '\n';
+  writeTextFileSync(pth, text);
+}
+
+
+// Prompt the user for input.
+function prompt(query, def='') {
+  const rl = readline.createInterface({
+    input:  process.stdin,
+    output: process.stdout
+  });
+  return new Promise(resolve => {
+    let q = def? `${query} [${def}]: ` : `${query}: `;
+    rl.question(q, answer => {
+      rl.close();
+      resolve(answer.trim()? answer : def);
+    });
+  });
+}
+//#endregion
+
+
+
+
+//#region SECTION COMMANDS
+// Remove excess section gaps (> 2).
+function sectionTrim(data, prefix) {
+  const pre = escapeRegExp(prefix);
+  const re  = new RegExp(`^${pre}endregion\n{4,}${pre}region.*?`, 'gm');
+  return data.replace(re, `${prefix}endregion\n\n\n${prefix}region`).trim() + '\n';
+}
+
+
+// Extract a section from a text file based on region markers.
+function sectionExtract(data, prefix, name) {
+  const pre = escapeRegExp(prefix);
+  const re  = new RegExp(`^${pre}region ${name}$([\\s\\S]*?)^${pre}endregion$`, 'g');
+  const m   = re.exec(data);
+  return m? m[1].trim() : null;
+}
+
+
+// Remove a section from a text file based on region markers.
+function sectionRemove(data, prefix, name) {
+  const pre = escapeRegExp(prefix);
+  const re  = new RegExp(`^${pre}region ${name}$[\\s\\S]*?^${pre}endregion$`, 'g');
+  return data.replace(re, '');
+}
+
+
+// Add a section to a text file based on region markers (if it doesn't already exist).
+function sectionAdd(data, prefix, name, content) {
+  if (sectionExists(data, prefix, name)) return data;
+  return data.trim() +
+    `\n\n\n` +
+    `${prefix}region ${name}\n` +
+    `${content.trim()}\n` +
+    `${prefix}endregion\n`;
+}
+
+
+// Replace a section in a text file based on region markers.
+function sectionReplace(data, prefix, name, content) {
+  const pre = escapeRegExp(prefix);
+  const re  = new RegExp(`^${pre}region ${name}$[\\s\\S]*?^${pre}endregion$`, 'g');
+  return data.replace(re,
+    `${prefix}region ${name}\n` +
+    `${content.trim()}\n` +
+    `${prefix}endregion\n`
+  );
+}
+//#endregion
+
+
+
+
+//#region VERSION COMMAND
+// Fetch the current version of the tool from package.json.
+function fetchVersion() {
+  const  p = readJSONFileSync(path.join(__dirname, 'package.json'));
+  return p.version || '0.0.0';
+}
+
+
+// Run the `version` command, which displays the current version of the tool.
+function runVersion() {
+  console.error(`cpoach version ${fetchVersion()}\n`);
+}
+//#endregion
+
+
+
+
+//#region HELP COMMAND
+// Run the help command, which displays usage information.
+function runHelp() {
+  console.error(
+    `cpoach - A C/C++ package manager using the npm registry (v${fetchVersion()})\n` +
+    `\n` +
+    `Usage: cpoach [command] [options]\n` +
+    `\n` +
+    `Commands:\n` +
+    `  init          Initialize a new C/C++ project.\n` +
+    `  install       Install dependencies.\n` +
+    `  build         Build the project.\n` +
+    `  run           Run the executable.\n` +
+    `  config        Configure dependencies.\n` +
+    `  format        Format code.\n` +
+    `  sanitize      Run sanitizers.\n` +
+    `  lint          Lint code.\n` +
+    `  i | includes  Generate compiler flags for include paths.\n` +
+    `\n` +
+    `Options:\n` +
+    `  --compiler [name]  Specify the compiler (msvc, gcc, clang). Default is gcc.\n` +
+    `  --msvc             Shortcut for --compiler msvc.\n` +
+    `  --gcc              Shortcut for --compiler gcc.\n` +
+    `  --clang            Shortcut for --compiler clang.\n`
+  );
+}
+//#endregion
+
+
+
+
+//#region INCLUDES COMMAND
 // Run the `includes` command, which generates compiler flags for include paths.
 function runIncludes(opt) {
   const includes = [];
@@ -14,40 +177,205 @@ function runIncludes(opt) {
   const FLAG = opt.compiler==='msvc'? '/I' : '-I';
   console.log(includes.map(pth => `${FLAG}"${pth}"`).join(' ').trim());
 }
+//#endregion
 
 
-// Run the help command, which displays usage information.
-function runHelp() {
-  console.error(
-    `Usage: cpoach [command] [options]\n` +
-    `\n` +
-    `Commands:\n` +
-    `  i | includes         Generate compiler flags for include paths.\n` +
+
+//#region INIT COMMAND
+// Get the Git repository URL from the current directory, if it exists.
+function gitRepoUrl() {
+  try   { return cp.execSync('git config --get remote.origin.url', {encoding: 'utf8'}).trim(); }
+  catch { return ''; }
+}
+
+
+// Initialize .gitignore to ignore dependencies and build artifacts.
+function initGitignore(cwd) {
+  const pth  = path.join(cwd, '.gitignore');
+  let   data = fs.existsSync(pth)? readTextFileSync(pth) : '';
+  if (!/node_modules\//.test(data)) data = sectionAdd(data, PRE, 'Dependencies', `node_modules/`);
+  if (!/build\//.test(data))        data = sectionAdd(data, PRE, 'Build', `build/`);
+  writeTextFileSync(pth, sectionTrim(data));
+}
+
+
+// Initialize .npmignore to ignore dependencies and build artifacts.
+function initNpmignore(cwd) {
+  const pth  = path.join(cwd, '.npmignore');
+  let   data = fs.existsSync(pth)? readTextFileSync(pth) : '';
+  if (!/build\//.test(data)) data = sectionAdd(data, PRE, 'Build', `build/`);
+  writeTextFileSync(pth, sectionTrim(data));
+}
+
+
+// Initialize source files based on package.json.
+function initSourceFiles(cwd, pkg) {
+  const p = pkg;
+  const files = p.sourceFiles || ['main.cxx'];
+  let    main = null;
+  for (const file of files) {
+    const pth = path.join(cwd, file);
+    const dir = path.dirname(pth);
+    if (!/\?|\*/.test(dir)) fs.mkdirSync(dir, {recursive: true});
+    if ( /\?|\*/.test(file)) continue;
+    if (fs.existsSync(pth))  continue;
+    if (/main\.(c|cxx|cpp|cc)$/.test(file)) main = main || pth;
+    fs.writeFileSync(pth, '');
+  }
+  if (!main) return;
+  const data = readTextFileSync(main);
+  if (data.trim()) return;
+  writeTextFileSync(main,
+    `#include <iostream>\n` +
     `\n` +
-    `Options:\n` +
-    `  --compiler [name]    Specify the compiler (msvc, gcc, clang). Default is gcc.\n` +
-    `  --msvc               Shortcut for --compiler msvc.\n` +
-    `  --gcc                Shortcut for --compiler gcc.\n` +
-    `  --clang              Shortcut for --compiler clang.\n`
+    `int main() {\n` +
+    `  std::cout << "Hello, world!\\n";\n` +
+    `  return 0;\n` +
+    `}\n`
   );
 }
 
 
-// Parse the command name.
-function parseCommand(opt, cmd) {
-  if (/i|includes/.test(cmd)) opt.command = 'includes';
-  else opt.error = `Unknown option: ${cmd}`;
+// Initialize CMakeLists.txt based on package.json.
+function initCMakeLists(cwd, pkg) {
+  const p = pkg;
+  const projectName  = p.name;
+  const isExecutable = p.type === 'executable';
+  const cxxStandard  = p.cmake.options.CMAKE_CXX_STANDARD || '17';
+  const generator    = p.cmake.generator || null;
+  const pth = path.join(cwd, 'CMakeLists.txt');
+  let data  = fs.existsSync(pth)? readTextFileSync(pth) : '';
+  if (!/cmake_minimum_required/.test(data)) {
+    data = sectionReplace(data, PRE, 'Project details',
+      `cmake_minimum_required(VERSION ${p.cmake.minVersion || '3.15'})\n` +
+      `project(${projectName} VERSION ${p.version} LANGUAGES CXX)\n`
+    );
+  }
+  data = sectionReplace(data, PRE, 'Include dependencies',
+    `include(dependencies.cmake OPTIONAL)`
+  );
+  if (!/set\(CMAKE_CXX_STANDARD\s/.test(data)) {
+    data = sectionReplace(data, PRE, 'Set C++ standard',
+      `set(CMAKE_CXX_STANDARD ${cxxStandard})\n` +
+      `set(CMAKE_CXX_STANDARD_REQUIRED ON)`
+    );
+  }
+  if (isExecutable) {
+    data = sectionReplace(data, PRE, 'Define executable target',
+      `add_executable(${projectName} main.cxx)\n` +
+      `target_include_directories(${projectName} PRIVATE include)`
+    );
+  }
+  else {
+    data = sectionReplace(data, PRE, 'Define library target',
+      `add_library(${projectName} main.cxx)\n` +
+      `target_include_directories(${projectName} PUBLIC include)`
+    );
+  }
+  data = sectionReplace(data, PRE, 'Link dependencies',
+    `# target_link_libraries(${projectName} PRIVATE dependencies)`
+  );
+  data = sectionReplace(data, PRE, 'Link system dependencies',
+    `# find_package(OpenSSL REQUIRED)\n` +
+    `# target_link_libraries(${projectName} PRIVATE OpenSSL::SSL)`
+  );
+  writeTextFileSync(pth, sectionTrim(data));
+}
+
+
+async function runInit() {
+  const cwd = process.cwd();
+  const pth = path.join(cwd, 'package.json');
+  if (fs.existsSync(pth)) {
+    const overwrite = await prompt('package.json already exists. Overwrite? (y/N) ');
+    if (overwrite.toLowerCase() !== 'y') { console.error('Aborted.'); return; }
+  }
+  // Gather project info
+  const name    = await prompt('Project name', path.basename(cwd));
+  const version = await prompt('Version', '1.0.0');
+  const description = await prompt('Description', '');
+  const type        = await prompt('Project type (executable/library)', 'executable');
+  const sourceFiles = await prompt('Source files (A; B)', 'main.cxx');
+  const cxxStandard = await prompt('C++ standard (11/14/17/20)', '17');
+  // const generator   = await prompt('CMake generator (Ninja/Makefiles/VS)', 'Ninja');
+  const testCommand = await prompt('Test command', 'echo "No tests defined"');
+  const gitRepo     = await prompt('Git repository URL', gitRepoUrl());
+  const keywords    = await prompt('Keywords (A; B)', '');
+  const author      = await prompt('Author', '');
+  const license     = await prompt('License', 'MIT');
+  // Create package.json
+  const pkg = {}, p = pkg;
+  p.name    = name;
+  p.version = version;
+  p.description = description;
+  p.type = type === 'executable'? 'executable' : 'library';
+  p.sourceFiles = sourceFiles.split(';').map(s => s.trim()).filter(s => s);
+  if (testCommand) p.scripts = {test: testCommand};
+  if (gitRepo) {
+    p.homepage = `${gitRepo}#readme`;
+    p.bugs = {url: `${gitRepo}/issues`};
+    p.repository = {
+      type: 'git',
+      url: gitRepo
+    };
+  }
+  p.keywords = keywords.split(';').map(s => s.trim()).filter(s => s);
+  if (author)  p.author  = author;
+  if (license) p.license = license;
+  p.dependencies = {};
+  p.devDependencies = {};
+  p.systemDependencies = {
+    linux: [],
+    darwin: [],
+    win32: []
+  };
+  p.cmake = {};
+  p.cmake.minVersion = '3.15';
+  if (generator) p.cmake.generator = generator;
+  p.cmake.options = {
+    CMAKE_CXX_STANDARD: cxxStandard,
+    BUILD_SHARED_LIBS: 'OFF'
+  }
+  // Default target same as name.
+  p.targets = [name];
+  writeJSONFileSync(pth, pkg);
+  initCMakeLists(cwd, pkg);
+  initGitignore(cwd);
+  initNpmignore(cwd);
+  initSourceFiles(cwd, pkg);
+  console.log('✓ Project initialized!\n');
 }
+//#endregion
+
+
+
 
+//#region PARSE ARG
 // Parse a single command-line argument.
 function parseArg(opt, argv, k, i) {
   if (k==='--help') opt.help = true;
-  else if (k==='--compiler') opt.compiler = argv[++i];
-  else if (k==='--msvc')  opt.compiler = 'msvc';
-  else if (k==='--gcc')   opt.compiler = 'gcc';
-  else if (k==='--clang') opt.compiler = 'clang';
-  else if (!opt.command)  parseCommand(opt, k);
-  else opt.error = `Unknown option: ${k}`;
+  else if (k==='--version') opt.version  = true;
+  // Parse command name.
+  else if (!opt.command) switch (k.toLowerCase()) {
+    case 'i':        opt.command = 'includes'; break;
+    case 'includes': opt.command = 'includes'; break;
+    case 'init':     opt.command = 'init'; break;
+    default: opt.error = `Unknown command: ${k}`; break;
+  }
+  // Parse command options.
+  else switch (opt.command) {
+    // Parse options for `includes` command.
+    case 'includes':
+      if (k==='--compiler')   opt.compiler = argv[++i];
+      else if (k==='--msvc')  opt.compiler = 'msvc';
+      else if (k==='--gcc')   opt.compiler = 'gcc';
+      else if (k==='--clang') opt.compiler = 'clang';
+      else opt.error = `Unknown option: ${k}`;
+      break;
+    // Parse options for `init` command.
+    case 'init':
+      break;
+  }
   return i;
 }
 
@@ -56,15 +384,20 @@ function parseArgs(argv) {
   const opt = {
     error: null,
     help: false,
-    command: 'includes',
+    version: false,
+    command: '',
     compiler: 'gcc'
   };
   for (let i=2; i<argv.length; i++)
     i = parseArg(opt, argv, argv[i], i);
   return opt;
 }
+//#endregion
+
 
 
+
+//#region MAIN
 // Main entry point.
 function main(argv) {
   const opt = parseArgs(argv);
@@ -77,13 +410,16 @@ function main(argv) {
     runHelp();
     process.exit(0);
   }
+  if (opt.version) {
+    runVersion();
+    process.exit(0);
+  }
   switch (opt.command) {
     case 'includes': runIncludes(opt); break;
-    default:
-      console.error(`Unknown command: ${opt.command}`);
-      process.exit(1);
+    case 'init':     runInit(opt); break;
   }
 }
 
 // Run the main entry point.
 main(process.argv);
+//#endregion

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "cpoach.sh",
-  "version": "0.2.4",
-  "description": "Support tool for for easy-to-use, C/C++ libraries that can be effortlessly installed via NPM.",
+  "version": "0.3.0",
+  "description": "A C/C++ package manager using the npm registry.",
   "keywords": [
     "c",
     "c++",
     "cpoach",
+    "package",
+    "manager",
     "includes",
     "support",
     "tool",

package/.github/workflows/on-push.yml

@@ -1,35 +0,0 @@
-name: On Push
-on:
-  push:
-    branches:
-      - main
-      - master
-    tags:
-      - '!*'  # Do not execute on tags
-env:
-  NAME:  ${{vars.NAME}}
-  EMAIL: ${{vars.EMAIL}}
-  NPM_TOKEN:    ${{secrets.NPM_TOKEN}}
-  GITHUB_TOKEN: ${{secrets.GH_TOKEN}}
-  FORCE_COLOR: 1
-
-
-jobs:
-  publish:
-    name: Publish packages
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
-        with:
-          node-version: 24.x
-      - uses: nodef/npm-config.action@v1.2.0
-        with:
-          credentials: auto
-          entries: access=public
-        env:
-          GITHUB_TOKEN: ${{env.GITHUB_TOKEN}}
-          NPM_TOKEN: ${{env.NPM_TOKEN}}
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{env.NPM_TOKEN}}