contextforge-cli-harshil 1.0.0

package/src/scan.js

@@ -0,0 +1,206 @@
+/**
+ * scan.js
+ * Scans the repository using fast-glob and returns a list of relevant files.
+ */
+
+import fg from 'fast-glob';
+import { readFileSync, existsSync } from 'fs';
+import { resolve, relative } from 'path';
+import ignore from 'ignore';
+
+// Patterns to always include
+const INCLUDE_PATTERNS = [
+  'src/**',
+  'lib/**',
+  'app/**',
+  'pages/**',
+  'components/**',
+  'routes/**',
+  'controllers/**',
+  'services/**',
+  'middleware/**',
+  'middlewares/**',
+  'models/**',
+  'schemas/**',
+  'prisma/**',
+  'config/**',
+  'configs/**',
+  'utils/**',
+  'helpers/**',
+  'hooks/**',
+  'store/**',
+  'api/**',
+  'docs/**',
+  'scripts/**',
+  'README.md',
+  'readme.md',
+  'package.json',
+  '.env.example',
+  '.env.sample',
+  'docker-compose.yml',
+  'docker-compose.yaml',
+  'Dockerfile',
+  'tsconfig.json',
+  'jsconfig.json',
+  'vite.config.*',
+  'next.config.*',
+  'webpack.config.*',
+  '.eslintrc*',
+  'babel.config.*',
+  'jest.config.*',
+  'tailwind.config.*',
+  'index.js',
+  'index.ts',
+  'main.js',
+  'main.ts',
+  'app.js',
+  'app.ts',
+  'server.js',
+  'server.ts',
+];
+
+// Patterns to always ignore
+const IGNORE_PATTERNS = [
+  'node_modules/**',
+  'dist/**',
+  'build/**',
+  '.git/**',
+  'coverage/**',
+  '.next/**',
+  '.nuxt/**',
+  '.cache/**',
+  '.turbo/**',
+  'out/**',
+  '**/*.log',
+  '**/*.lock',
+  '**/*.min.js',
+  '**/*.min.css',
+  '**/*.map',
+  '**/*.snap',
+  '**/*.png',
+  '**/*.jpg',
+  '**/*.jpeg',
+  '**/*.gif',
+  '**/*.svg',
+  '**/*.ico',
+  '**/*.woff',
+  '**/*.woff2',
+  '**/*.ttf',
+  '**/*.eot',
+  '**/*.mp4',
+  '**/*.mp3',
+  '**/*.pdf',
+  '**/*.zip',
+  '**/*.tar.gz',
+  'context.md',
+  '.env',
+];
+
+/**
+ * Reads .gitignore if present and returns an `ignore` instance.
+ * @param {string} cwd
+ */
+function loadGitignore(cwd) {
+  const gitignorePath = resolve(cwd, '.gitignore');
+  const ig = ignore();
+  if (existsSync(gitignorePath)) {
+    const content = readFileSync(gitignorePath, 'utf-8');
+    ig.add(content);
+  }
+  return ig;
+}
+
+/**
+ * Scan the repository and return an array of file entries.
+ * Each entry: { path: string (relative), absolutePath: string }
+ *
+ * @param {string} cwd - Root directory to scan
+ * @returns {Promise<Array<{ path: string, absolutePath: string }>>}
+ */
+export async function scanRepository(cwd) {
+  const ig = loadGitignore(cwd);
+
+  const files = await fg(INCLUDE_PATTERNS, {
+    cwd,
+    ignore: IGNORE_PATTERNS,
+    dot: true,
+    followSymbolicLinks: false,
+    onlyFiles: true,
+    absolute: false,
+  });
+
+  // Filter through .gitignore rules
+  const filtered = files.filter((f) => {
+    try {
+      return !ig.ignores(f);
+    } catch {
+      return true;
+    }
+  });
+
+  // Sort for deterministic ordering
+  filtered.sort();
+
+  return filtered.map((f) => ({
+    path: f,
+    absolutePath: resolve(cwd, f),
+  }));
+}
+
+/**
+ * Read the content of a file safely (returns null if unreadable / too large).
+ * @param {string} absolutePath
+ * @param {number} maxBytes - default 80KB
+ * @returns {string|null}
+ */
+export function readFileSafe(absolutePath, maxBytes = 80_000) {
+  try {
+    const content = readFileSync(absolutePath, 'utf-8');
+    if (content.length > maxBytes) {
+      return content.slice(0, maxBytes) + '\n\n[... truncated for context ...]';
+    }
+    return content;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build a simple tree-style folder structure string.
+ * @param {Array<{path:string}>} files
+ * @returns {string}
+ */
+export function buildFolderTree(files) {
+  const dirs = new Set();
+  files.forEach(({ path }) => {
+    const parts = path.split('/');
+    for (let i = 1; i < parts.length; i++) {
+      dirs.add(parts.slice(0, i).join('/'));
+    }
+  });
+
+  // Gather top-level entries
+  const topLevel = new Set();
+  files.forEach(({ path }) => {
+    topLevel.add(path.split('/')[0]);
+  });
+
+  let tree = './\n';
+  const allEntries = [
+    ...Array.from(dirs).sort(),
+    ...files.map((f) => f.path).filter((p) => !p.includes('/')),
+  ].sort();
+
+  const seen = new Set();
+  allEntries.forEach((entry) => {
+    if (seen.has(entry)) return;
+    seen.add(entry);
+    const depth = entry.split('/').length - 1;
+    const indent = '  '.repeat(depth);
+    const isDir = dirs.has(entry);
+    const name = entry.split('/').pop();
+    tree += `${indent}${isDir ? '📁 ' : '📄 '}${name}\n`;
+  });
+
+  return tree;
+}

package/src/utils.js

@@ -0,0 +1,93 @@
+/**
+ * utils.js
+ * Shared utilities for logging, formatting, and path helpers.
+ */
+
+import chalk from 'chalk';
+
+// ── Logger ───────────────────────────────────────────────────────────────────
+
+export const logger = {
+  info(msg) {
+    console.log(chalk.cyan('  ℹ ') + chalk.white(msg));
+  },
+  success(msg) {
+    console.log(chalk.green('  ✓ ') + chalk.white(msg));
+  },
+  warn(msg) {
+    console.log(chalk.yellow('  ⚠ ') + chalk.yellow(msg));
+  },
+  error(msg) {
+    console.error(chalk.red('  ✗ ') + chalk.red(msg));
+  },
+  dim(msg) {
+    console.log(chalk.dim('    ' + msg));
+  },
+  blank() {
+    console.log('');
+  },
+  divider() {
+    console.log(chalk.dim('  ' + '─'.repeat(50)));
+  },
+  header(title) {
+    console.log('');
+    console.log(chalk.bold.cyan(`  ${title}`));
+    console.log(chalk.dim('  ' + '─'.repeat(50)));
+  },
+};
+
+// ── Formatting ───────────────────────────────────────────────────────────────
+
+/**
+ * Format bytes into a human-readable string.
+ * @param {number} bytes
+ * @returns {string}
+ */
+export function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+/**
+ * Truncate a string to a max length with ellipsis.
+ * @param {string} str
+ * @param {number} max
+ * @returns {string}
+ */
+export function truncate(str, max = 60) {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 3) + '...';
+}
+
+/**
+ * Format elapsed time in ms to a readable string.
+ * @param {number} ms
+ * @returns {string}
+ */
+export function formatDuration(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+
+// ── Validation ───────────────────────────────────────────────────────────────
+// API key validation is handled by src/ai.js → validateProviderKey()
+
+// ── Security ─────────────────────────────────────────────────────────────────
+
+/**
+ * Sanitize an error message before printing to terminal.
+ * Redacts anything that looks like an API key or bearer token
+ * to prevent accidental credential leakage in logs.
+ *
+ * @param {string} msg
+ * @returns {string}
+ */
+export function sanitizeErrorMessage(msg) {
+  if (!msg) return 'Unknown error';
+  return String(msg)
+    .replace(/sk-[A-Za-z0-9\-_]{10,}/g, 'sk-[REDACTED]')
+    .replace(/gsk_[A-Za-z0-9\-_]{10,}/g, 'gsk_[REDACTED]')
+    .replace(/Bearer\s+\S+/gi, 'Bearer [REDACTED]')
+    .replace(/Authorization:\s*\S+/gi, 'Authorization: [REDACTED]');
+}