@mattgraba/dev-toolkit 2.0.1

package/cli/utils/fileScanner.js

@@ -0,0 +1,107 @@
+// utils/fileScanner.js
+
+import fg from "fast-glob";
+import fs from "fs";
+import path from "path";
+import ignore from "ignore";
+
+// Files that must never be sent to an AI API, gitignored or not.
+// .gitignore handles the common cases; this is the safety net for
+// credential-shaped files that a project forgot to ignore.
+const SECRET_FILE_PATTERNS = [
+  /\.pem$/i,
+  /\.key$/i,
+  /\.p12$/i,
+  /\.pfx$/i,
+  /id_rsa/i,
+  /id_ed25519/i,
+  /credential/i,
+  /secret/i,
+  /\.env(\.|$)/i,
+];
+
+function looksLikeSecretFile(relativePath) {
+  return SECRET_FILE_PATTERNS.some((pattern) => pattern.test(relativePath));
+}
+
+/**
+ * Reads and parses .gitignore from the provided directory
+ */
+function loadGitignore(directory) {
+  const ig = ignore();
+  const gitignorePath = path.join(directory, ".gitignore");
+
+  if (fs.existsSync(gitignorePath)) {
+    const gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
+    ig.add(gitignoreContent.split(/\r?\n/));
+  }
+
+  return ig;
+}
+
+/**
+ * Scan project directory for relevant files
+ * @param {Object} options
+ * @param {string} options.directory - root directory to scan
+ * @param {string[]} options.extensions - file extensions to include
+ * @param {number} options.maxFileSizeKB - max file size to include
+ * @param {number} options.maxFiles - max number of files to include
+ * @param {string[]} options.exclude - folders to exclude
+ * @returns {Promise<Array<{ name: string, content: string }>>}
+ */
+async function scanFiles({
+  directory = ".",
+  extensions = ["js", "ts", "json"],
+  maxFileSizeKB = 20,
+  maxFiles = 50,
+  exclude = ["node_modules", ".git", "dist", "build"]
+}) {
+  // Match all files with specified extensions
+  const patterns = extensions.map((ext) => `**/*.${ext}`);
+  const excludePatterns = exclude.map((dir) => `${dir}/**`);
+
+  // Build ignore patterns like "node_modules/**"
+  const gitignore = loadGitignore(directory);
+
+  const entries = await fg(patterns, {
+    cwd: directory,
+    ignore: excludePatterns,
+    dot: false,          // Ignore hidden files like .env, .vscode
+    onlyFiles: true,
+    absolute: true,      // Easier for fs.readFileSync
+  });
+
+  const results = [];
+
+  for (const absolutePath of entries) {
+    if (results.length >= maxFiles) {
+      console.warn(`⚠️ Context capped at ${maxFiles} files; remaining files skipped.`);
+      break;
+    }
+
+    try {
+      const relativePath = path.relative(directory, absolutePath);
+
+      if (gitignore.ignores(relativePath)) continue;
+
+      if (looksLikeSecretFile(relativePath)) {
+        console.warn(`⚠️ Skipping ${relativePath}: filename looks credential-related`);
+        continue;
+      }
+
+      const stats = fs.statSync(absolutePath);
+      const sizeKB = stats.size / 1024;
+
+      if (sizeKB <= maxFileSizeKB) {
+        const content = fs.readFileSync(absolutePath, "utf-8");
+        results.push({ name: relativePath, content });
+      }
+    } catch (err) {
+      console.warn(`Skipping file ${absolutePath}: ${err.message}`);
+    }
+  }
+
+  return results;
+}
+
+export { scanFiles };

package/cli/utils/formatBox.js

@@ -0,0 +1,146 @@
+// cli/utils/formatBox.js
+// Boxed rendering for analyze results, ported from the stranded pre-v2
+// "structured boxed output" work (e20e5fe) onto the v2 CLI structure.
+
+import chalk from 'chalk';
+
+/**
+ * Word-wraps text to fit within a given width, preserving existing line breaks.
+ */
+function wordWrap(text, maxWidth) {
+  const lines = [];
+  for (const rawLine of text.split('\n')) {
+    if (rawLine.length <= maxWidth) {
+      lines.push(rawLine);
+      continue;
+    }
+    const words = rawLine.split(' ');
+    let current = '';
+    for (const word of words) {
+      if (current.length + word.length + 1 > maxWidth) {
+        lines.push(current);
+        current = word;
+      } else {
+        current = current ? `${current} ${word}` : word;
+      }
+    }
+    if (current) lines.push(current);
+  }
+  return lines;
+}
+
+/**
+ * Renders a boxed analysis result:
+ *
+ *   ┌─ Analysis Result ──────────────────────────────┐
+ *   │                                                │
+ *   │  File:    ./brokenFunction.ts                  │
+ *   │  Status:  2 issues found                       │
+ *   │                                                │
+ *   │  [1] Line 14 — Uncaught promise rejection      │
+ *   │      description text...                       │
+ *   │                                                │
+ *   │  Suggestion:                                   │
+ *   │      ...                                       │
+ *   │                                                │
+ *   └────────────────────────────────────────────────┘
+ */
+export function renderAnalysisBox({ filePath, issues = [], suggestion = '' }) {
+  const termWidth = Math.min(process.stdout.columns || 80, 80);
+  const boxWidth = Math.max(termWidth - 4, 40); // leave margin
+  const innerWidth = boxWidth - 4; // 2 for "│  " and 2 for "  │"
+  const pad = 2; // left padding inside box
+
+  const border = chalk.cyan;
+  const padStr = ' '.repeat(pad);
+
+  // Build content lines (plain strings, padded at render time)
+  const contentLines = [''];
+
+  contentLines.push(`File:    ${filePath}`);
+  const issueCount = issues.length;
+  const statusText = issueCount === 0
+    ? 'No issues found'
+    : `${issueCount} issue${issueCount !== 1 ? 's' : ''} found`;
+  contentLines.push(`Status:  ${statusText}`);
+  contentLines.push('');
+
+  for (let i = 0; i < issues.length; i++) {
+    const issue = issues[i];
+    const lineRef = issue.line != null ? `Line ${issue.line}` : 'General';
+    const header = `[${i + 1}] ${lineRef} — ${issue.title}`;
+
+    for (const wl of wordWrap(header, innerWidth)) {
+      contentLines.push(wl);
+    }
+
+    if (issue.detail) {
+      for (const dl of wordWrap(issue.detail, innerWidth - 4)) {
+        contentLines.push(`    ${dl}`);
+      }
+    }
+
+    contentLines.push('');
+  }
+
+  if (suggestion) {
+    contentLines.push(chalk.green('Suggestion:'));
+    for (const sl of wordWrap(suggestion, innerWidth - 4)) {
+      contentLines.push(`    ${sl}`);
+    }
+    contentLines.push('');
+  }
+
+  // Row layout: "  │" + pad + innerWidth + pad + "│" — so the horizontal
+  // span between the corners is pad + innerWidth + pad = boxWidth.
+  const titleText = ' Analysis Result ';
+  const top = border(`  ┌─${titleText}${'─'.repeat(Math.max(boxWidth - 1 - titleText.length, 0))}┐`);
+  const bottom = border(`  └${'─'.repeat(boxWidth)}┘`);
+
+  const output = [top];
+
+  for (const line of contentLines) {
+    // Strip ANSI for length calculation
+    const plainLine = line.replace(new RegExp(String.fromCharCode(27) + '\[[0-9;]*m', 'g'), '');
+    const rightPad = Math.max(innerWidth - plainLine.length, 0);
+    output.push(`  ${border('│')}${padStr}${line}${' '.repeat(rightPad)}${padStr}${border('│')}`);
+  }
+
+  output.push(bottom);
+
+  console.log(output.join('\n'));
+}
+
+/**
+ * Parses a structured JSON analysis response from the AI.
+ * Handles markdown code fences and falls back gracefully to a
+ * single-issue shape when the model didn't return valid JSON.
+ */
+export function parseAnalysisJSON(rawText) {
+  let text = rawText.trim();
+  const fenceMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)```/i);
+  if (fenceMatch) {
+    text = fenceMatch[1].trim();
+  }
+
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed.issues && Array.isArray(parsed.issues)) {
+      return {
+        issues: parsed.issues.map(i => ({
+          line: i.line ?? null,
+          title: i.title || 'Issue',
+          detail: i.detail || '',
+        })),
+        suggestion: parsed.suggestion || '',
+      };
+    }
+  } catch {
+    // Fall through to fallback
+  }
+
+  return {
+    issues: [{ line: null, title: 'Analysis', detail: rawText.trim() }],
+    suggestion: '',
+  };
+}

package/cli/utils/fsUtils.js

@@ -0,0 +1,13 @@
+// utils/fsUtils.js
+import fs from 'fs';
+import chalk from 'chalk';
+
+function checkFileExists(filePath) {
+  if (!fs.existsSync(filePath)) {
+    console.error(chalk.red(`❌ File not found: ${filePath}`));
+    return false;
+  }
+  return true;
+}
+
+export { checkFileExists };

package/cli/utils/historySaver.js

@@ -0,0 +1,24 @@
+import { getToken } from './configManager.js';
+import { appendLocalHistory } from './localHistory.js';
+
+/**
+ * Saves a command result to history.
+ *
+ * Hosted mode: the server already records history inside each AI route,
+ * so the CLI does nothing here (posting to /history as well would create
+ * duplicate entries — which is exactly what earlier versions did).
+ *
+ * BYOK mode (no login token): history is saved locally instead.
+ */
+async function saveToHistory({ command, input, output }) {
+  if (getToken()) return; // hosted mode — server-side history already saved
+
+  try {
+    appendLocalHistory({ command, input, output });
+  } catch (err) {
+    // History must never break the main command, but don't hide the failure
+    console.warn(`⚠️ Could not save history: ${err.message}`);
+  }
+}
+
+export default saveToHistory;

package/cli/utils/localHistory.js

@@ -0,0 +1,44 @@
+// cli/utils/localHistory.js
+// File-based history for BYOK mode — no account or server required.
+// Hosted-mode history lives server-side; this is the local equivalent.
+
+import fs from 'fs';
+import path from 'path';
+import { CONFIG_DIR, SECRET_FILE_MODE } from './configManager.js';
+
+const HISTORY_FILE = path.join(CONFIG_DIR, 'history.json');
+const MAX_ENTRIES = 100;
+
+function readLocalHistory() {
+  if (!fs.existsSync(HISTORY_FILE)) {
+    return [];
+  }
+  try {
+    const entries = JSON.parse(fs.readFileSync(HISTORY_FILE, 'utf-8'));
+    return Array.isArray(entries) ? entries : [];
+  } catch {
+    return [];
+  }
+}
+
+function appendLocalHistory({ command, input, output }) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  }
+
+  const entries = readLocalHistory();
+  entries.unshift({
+    command,
+    input,
+    output,
+    createdAt: new Date().toISOString(),
+  });
+
+  // History can contain source code — same owner-only mode as the config file.
+  fs.writeFileSync(HISTORY_FILE, JSON.stringify(entries.slice(0, MAX_ENTRIES), null, 2), {
+    encoding: 'utf-8',
+    mode: SECRET_FILE_MODE,
+  });
+}
+
+export { HISTORY_FILE, MAX_ENTRIES, readLocalHistory, appendLocalHistory };

package/cli/utils/promptPassword.js

@@ -0,0 +1,74 @@
+// cli/utils/promptPassword.js
+// Masked password input using raw-mode stdin — no dependency needed.
+// Echoes '*' per keystroke, supports backspace and Ctrl+C.
+
+const CTRL_C = '';
+const BACKSPACE = '';
+
+function promptPassword(promptText) {
+  return new Promise((resolve, reject) => {
+    const { stdin, stdout } = process;
+
+    stdout.write(promptText);
+
+    if (!stdin.isTTY) {
+      // Piped input (tests, scripts): read one line without raw mode
+      let piped = '';
+      stdin.setEncoding('utf-8');
+      stdin.on('data', function onData(chunk) {
+        piped += chunk;
+        const newline = piped.indexOf('\n');
+        if (newline !== -1) {
+          stdin.removeListener('data', onData);
+          stdin.pause();
+          resolve(piped.slice(0, newline).replace(/\r$/, ''));
+        }
+      });
+      return;
+    }
+
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf-8');
+
+    let password = '';
+
+    function done(err, value) {
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener('data', onKeypress);
+      stdout.write('\n');
+      if (err) reject(err);
+      else resolve(value);
+    }
+
+    function onKeypress(char) {
+      switch (char) {
+        case '\r':
+        case '\n':
+          done(null, password);
+          break;
+        case CTRL_C:
+          done(new Error('Cancelled'));
+          break;
+        case BACKSPACE:
+        case '\b':
+          if (password.length > 0) {
+            password = password.slice(0, -1);
+            stdout.write('\b \b');
+          }
+          break;
+        default:
+          // Ignore other control characters (arrows etc.)
+          if (char >= ' ') {
+            password += char;
+            stdout.write('*');
+          }
+      }
+    }
+
+    stdin.on('data', onKeypress);
+  });
+}
+
+export default promptPassword;

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@mattgraba/dev-toolkit",
+  "version": "2.0.1",
+  "description": "Dev Toolkit — an AI-assisted developer CLI for analyzing errors, debugging issues, and scaffolding projects. BYOK-first; optional hosted mode.",
+  "type": "module",
+  "bin": {
+    "devtk": "bin/devtk.js"
+  },
+  "files": [
+    "bin",
+    "cli",
+    "!cli/tests",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev:cli": "node cli/cli.js",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --detectOpenHandles --forceExit"
+  },
+  "keywords": [
+    "cli",
+    "developer-tools",
+    "ai",
+    "debugging",
+    "productivity",
+    "openai",
+    "byok",
+    "open-source"
+  ],
+  "author": "Matt Graba",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mattgraba/dev-toolkit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mattgraba/dev-toolkit/issues"
+  },
+  "homepage": "https://github.com/mattgraba/dev-toolkit#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "preferGlobal": true,
+  "publishConfig": {
+    "access": "public"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "transform": {},
+    "testPathIgnorePatterns": [
+      "/node_modules/",
+      "/server/",
+      "/client/"
+    ]
+  },
+  "dependencies": {
+    "axios": "^1.10.0",
+    "chalk": "^4.1.2",
+    "commander": "^14.0.0",
+    "dotenv": "^17.2.0",
+    "fast-glob": "^3.3.3",
+    "ignore": "^7.0.5",
+    "openai": "^5.20.3",
+    "ora": "^5.4.1"
+  },
+  "devDependencies": {
+    "jest": "^30.0.4"
+  }
+}