cobolx 1.0.0

package/Cargo.toml

@@ -0,0 +1,39 @@
+[package]
+name = "rdo"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+clap = { version = "4.5", features = ["derive"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+colored = "2.1"
+chrono = { version = "0.4", features = ["serde"] }
+ratatui = "0.26"
+crossterm = "0.27"
+reqwest = { version = "0.12", default-features = false, features = ["json", "stream", "rustls-tls"] }
+tokio = { version = "1", features = ["full"] }
+directories = "5.0"
+futures-util = "0.3"
+rusqlite = { version = "0.40.1", features = ["bundled"] }
+
+[dev-dependencies]
+tempfile = "3.8"
+
+[lints.rust]
+unused_variables = "warn"
+dead_code = "allow"
+
+[lints.clippy]
+collapsible_if = "allow"
+new_without_default = "allow"
+implicit_saturating_sub = "allow"
+manual_div_ceil = "allow"
+if_same_then_else = "allow"
+module_inception = "allow"
+unnecessary_map_or = "allow"
+needless_range_loop = "allow"
+
+
+
+

package/bin/check-update.js

@@ -0,0 +1,44 @@
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+
+const pkg = require('../package.json');
+const noticeFile = path.join(__dirname, '.update-notice');
+
+const options = {
+  hostname: 'registry.npmjs.org',
+  path: `/${pkg.name}/latest`,
+  timeout: 3000,
+  headers: {
+    'User-Agent': 'cobolx-cli-update-checker'
+  }
+};
+
+const req = https.get(options, (res) => {
+  if (res.statusCode !== 200) return;
+  let data = '';
+  res.on('data', (chunk) => { data += chunk; });
+  res.on('end', () => {
+    try {
+      const info = JSON.parse(data);
+      const latest = info.version;
+      if (latest && latest !== pkg.version) {
+        const msg = [
+          '\x1b[33m---------------------------------------------------------\x1b[0m',
+          `  💡 \x1b[36mUpdate available:\x1b[0m \x1b[32m${latest}\x1b[0m (current: ${pkg.version})`,
+          `     Run \x1b[33mnpm update -g ${pkg.name}\x1b[0m to update!`,
+          '\x1b[33m---------------------------------------------------------\x1b[0m'
+        ].join('\n');
+        fs.writeFileSync(noticeFile, msg, 'utf8');
+      }
+    } catch (e) {
+      // ignore
+    }
+  });
+});
+
+req.on('error', () => {
+  // ignore
+});
+
+req.end();

package/bin/cobolx.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const isWin = process.platform === 'win32';
+const binName = isWin ? 'cobolx.exe' : 'cobolx';
+const binaryPath = path.join(__dirname, binName);
+
+if (!fs.existsSync(binaryPath)) {
+  console.error(`Error: Native binary not found at ${binaryPath}`);
+  console.error('Please try reinstalling the package: npm install -g cobolx');
+  process.exit(1);
+}
+
+// 1. Check for pending update notification from previous background checks
+const noticeFile = path.join(__dirname, '.update-notice');
+if (fs.existsSync(noticeFile)) {
+  try {
+    const notice = fs.readFileSync(noticeFile, 'utf8').trim();
+    if (notice) {
+      console.log('\n' + notice);
+    }
+    fs.unlinkSync(noticeFile);
+  } catch (err) {
+    // ignore
+  }
+}
+
+// 2. Start the native binary child process
+const args = process.argv.slice(2);
+const child = spawn(binaryPath, args, { stdio: 'inherit' });
+
+child.on('error', (err) => {
+  console.error('Failed to start the native binary:', err);
+  process.exit(1);
+});
+
+child.on('close', (code) => {
+  // 3. Trigger background update check
+  triggerBackgroundUpdateCheck();
+  process.exit(code ?? 0);
+});
+
+function triggerBackgroundUpdateCheck() {
+  try {
+    const pkg = require('../package.json');
+    const cacheFile = path.join(__dirname, '.last-update-check');
+    const CHECK_INTERVAL = 24 * 60 * 60 * 1000; // 24 hours
+    const now = Date.now();
+    
+    let lastCheck = 0;
+    if (fs.existsSync(cacheFile)) {
+      lastCheck = parseInt(fs.readFileSync(cacheFile, 'utf8'), 10) || 0;
+    }
+
+    if (now - lastCheck < CHECK_INTERVAL) {
+      return;
+    }
+
+    // Write new timestamp immediately to throttle requests
+    fs.writeFileSync(cacheFile, now.toString(), 'utf8');
+
+    // Spawn a detached background process to check for updates
+    const checkerScript = path.join(__dirname, 'check-update.js');
+    
+    // Ignore outputs or pipe to a log file
+    const logFile = path.join(__dirname, '.checker-log');
+    const out = fs.openSync(logFile, 'a');
+    
+    const child = spawn(process.execPath, [checkerScript], {
+      detached: true,
+      stdio: ['ignore', out, out]
+    });
+    
+    child.unref();
+  } catch (err) {
+    // ignore
+  }
+}

package/docker-compose.yml

@@ -0,0 +1,33 @@
+services:
+  dev:
+    build:
+      context: .
+      dockerfile: dockerfile
+    command: sleep infinity
+    stdin_open: true
+    tty: true
+    environment:
+      CARGO_TARGET_DIR: /workspaces/cobolX/target
+      RUST_BACKTRACE: "1"
+    volumes:
+      - .:/workspaces/cobolX:cached
+      - cargo-registry:/usr/local/cargo/registry
+      - cargo-git:/usr/local/cargo/git
+      - target-cache:/workspaces/cobolX/target
+
+  test:
+    profiles:
+      - test
+    build:
+      context: .
+      dockerfile: dockerfile.test
+    stdin_open: true
+    tty: true
+    environment:
+      RUST_BACKTRACE: "1"
+      TERM: xterm-256color
+
+volumes:
+  cargo-registry:
+  cargo-git:
+  target-cache:

package/dockerfile

@@ -0,0 +1,18 @@
+# syntax=docker/dockerfile:1
+
+FROM mcr.microsoft.com/devcontainers/rust:1-bookworm
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+        ca-certificates \
+        git \
+        pkg-config \
+        libssl-dev \
+        gdb \
+        lldb \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN mkdir -p /workspaces/cobolX/target \
+    && chown -R vscode:vscode /workspaces
+
+WORKDIR /workspaces/cobolX

package/dockerfile.test

@@ -0,0 +1,39 @@
+# syntax=docker/dockerfile:1
+
+FROM rust:1-bookworm AS build
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+    ca-certificates \
+    pkg-config \
+    libssl-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY Cargo.toml Cargo.lock ./
+COPY src ./src
+COPY tests ./tests
+
+ENV CARGO_TARGET_DIR=/app/target \
+    RUST_BACKTRACE=1
+
+RUN cargo test --locked --release
+RUN cargo build --locked --release
+
+FROM debian:bookworm-slim AS runtime
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+    ca-certificates \
+    libssl3 \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY --from=build /app/target/release/rdo /usr/local/bin/rdo
+COPY example /app/example
+ENV RUST_BACKTRACE=1 \
+    TERM=xterm-256color
+
+CMD ["rdo"]

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "cobolx",
+  "version": "1.0.0",
+  "description": "CobolX CLI",
+  "main": "bin/cobolx.js",
+  "bin": {
+    "cobolx": "./bin/cobolx.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/install.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/WSPlXA/cobolX.git"
+  },
+  "keywords": [
+    "cobol",
+    "rust",
+    "cli"
+  ],
+  "author": "WSPlXA",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/WSPlXA/cobolX/issues"
+  },
+  "homepage": "https://github.com/WSPlXA/cobolX#readme"
+}

package/scripts/install.js

@@ -0,0 +1,145 @@
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { execSync } = require('child_process');
+
+const pkg = require('../package.json');
+const version = pkg.version;
+const repo = 'WSPlXA/cobolX';
+const binDir = path.join(__dirname, '../bin');
+
+// Map process.platform and process.arch to Rust target triples and archives
+function getTarget() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  if (platform === 'win32' && arch === 'x64') {
+    return {
+      triple: 'x86_64-pc-windows-msvc',
+      ext: 'zip'
+    };
+  }
+  if (platform === 'darwin') {
+    if (arch === 'x64') {
+      return {
+        triple: 'x86_64-apple-darwin',
+        ext: 'tar.gz'
+      };
+    }
+    if (arch === 'arm64') {
+      return {
+        triple: 'aarch64-apple-darwin',
+        ext: 'tar.gz'
+      };
+    }
+  }
+  if (platform === 'linux') {
+    if (arch === 'x64') {
+      return {
+        triple: 'x86_64-unknown-linux-gnu',
+        ext: 'tar.gz'
+      };
+    }
+    if (arch === 'arm64') {
+      return {
+        triple: 'aarch64-unknown-linux-gnu',
+        ext: 'tar.gz'
+      };
+    }
+  }
+
+  throw new Error(`Unsupported platform/architecture: ${platform}/${arch}`);
+}
+
+function downloadFile(url, dest, callback) {
+  https.get(url, (res) => {
+    if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+      // Follow redirect
+      downloadFile(res.headers.location, dest, callback);
+    } else if (res.statusCode === 200) {
+      const file = fs.createWriteStream(dest);
+      res.pipe(file);
+      file.on('finish', () => {
+        file.close(callback);
+      });
+    } else {
+      callback(new Error(`Failed to download: HTTP ${res.statusCode} ${res.statusMessage}`));
+    }
+  }).on('error', (err) => {
+    callback(err);
+  });
+}
+
+function install() {
+  try {
+    const target = getTarget();
+    const archiveName = `rdo-${target.triple}.${target.ext}`;
+    const downloadUrl = `https://github.com/${repo}/releases/download/v${version}/${archiveName}`;
+    const tempFile = path.join(binDir, `temp-${archiveName}`);
+
+    console.log(`Downloading CobolX binary for ${target.triple}...`);
+    
+    // Ensure bin directory exists
+    if (!fs.existsSync(binDir)) {
+      fs.mkdirSync(binDir, { recursive: true });
+    }
+
+    downloadFile(downloadUrl, tempFile, (err) => {
+      if (err) {
+        console.error('Error downloading binary:', err.message);
+        process.exit(1);
+      }
+
+      console.log('Extracting binary...');
+      try {
+        if (target.ext === 'zip') {
+          // Decompress zip on Windows using PowerShell
+          const cmd = `powershell -Command "Expand-Archive -Path '${tempFile}' -DestinationPath '${binDir}' -Force"`;
+          execSync(cmd, { stdio: 'inherit' });
+        } else {
+          // Decompress tar.gz on Unix
+          const cmd = `tar -xzf "${tempFile}" -C "${binDir}"`;
+          execSync(cmd, { stdio: 'inherit' });
+        }
+
+        // Clean up temp archive
+        fs.unlinkSync(tempFile);
+
+        // Rename the binary from 'rdo' to 'cobolx'
+        const rawBinName = target.ext === 'zip' ? 'rdo.exe' : 'rdo';
+        const finalBinName = target.ext === 'zip' ? 'cobolx.exe' : 'cobolx';
+
+        const rawBinPath = path.join(binDir, rawBinName);
+        const finalBinPath = path.join(binDir, finalBinName);
+
+        if (fs.existsSync(rawBinPath)) {
+          fs.renameSync(rawBinPath, finalBinPath);
+        } else {
+          // Check if it was already named correctly or packaged differently
+          if (!fs.existsSync(finalBinPath)) {
+            throw new Error(`Could not find extracted binary in ${binDir}`);
+          }
+        }
+
+        // Set execution permissions on Unix
+        if (target.ext !== 'zip') {
+          fs.chmodSync(finalBinPath, 0o755);
+        }
+
+        console.log('CobolX binary installed successfully.');
+      } catch (extractErr) {
+        console.error('Error extracting binary:', extractErr.message);
+        // Clean up temp file in case of failure
+        if (fs.existsSync(tempFile)) {
+          fs.unlinkSync(tempFile);
+        }
+        process.exit(1);
+      }
+    });
+  } catch (err) {
+    console.error('Installation failed:', err.message);
+    process.exit(1);
+  }
+}
+
+install();