nubos-pilot 0.2.2 → 0.4.0

package/lib/codebase-docs.test.cjs

@@ -0,0 +1,266 @@
+const { test, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const d = require('./codebase-docs.cjs');
+
+const _sandboxes = [];
+
+function makeSandbox() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'np-cbd-'));
+  _sandboxes.push(dir);
+  return dir;
+}
+
+function write(root, rel, content) {
+  const abs = path.join(root, rel);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, content);
+}
+
+afterEach(() => {
+  while (_sandboxes.length) {
+    const dir = _sandboxes.pop();
+    try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
+  }
+});
+
+test('CD-1: languageForExt maps known extensions', () => {
+  assert.equal(d.languageForExt('.js'), 'javascript');
+  assert.equal(d.languageForExt('.ts'), 'typescript');
+  assert.equal(d.languageForExt('.py'), 'python');
+  assert.equal(d.languageForExt('.rs'), 'rust');
+  assert.equal(d.languageForExt('.go'), 'go');
+  assert.equal(d.languageForExt('.xyz'), 'unknown');
+});
+
+test('CD-2: isCodeExt excludes docs and data', () => {
+  assert.equal(d.isCodeExt('.js'), true);
+  assert.equal(d.isCodeExt('.py'), true);
+  assert.equal(d.isCodeExt('.md'), false);
+  assert.equal(d.isCodeExt('.json'), false);
+  assert.equal(d.isCodeExt('.css'), false);
+});
+
+test('CD-3: groupFilesIntoModules clusters by directory', () => {
+  const files = [
+    { path: 'src/auth/login.js', ext: '.js' },
+    { path: 'src/auth/session.js', ext: '.js' },
+    { path: 'src/billing/invoice.js', ext: '.js' },
+    { path: 'README.md', ext: '.md' },
+  ];
+  const modules = d.groupFilesIntoModules(files);
+  assert.equal(modules.length, 2);
+  const auth = modules.find((m) => m.directory === 'src/auth');
+  assert.equal(auth.file_count, 2);
+  assert.equal(auth.primary_language, 'javascript');
+  const billing = modules.find((m) => m.directory === 'src/billing');
+  assert.deepEqual(billing.source_paths, ['src/billing/invoice.js']);
+});
+
+test('CD-4: groupFilesIntoModules detects mixed-language module', () => {
+  const files = [
+    { path: 'services/api/main.py', ext: '.py' },
+    { path: 'services/api/helper.py', ext: '.py' },
+    { path: 'services/api/tool.go', ext: '.go' },
+  ];
+  const modules = d.groupFilesIntoModules(files);
+  assert.equal(modules.length, 1);
+  assert.equal(modules[0].primary_language, 'python');
+  assert.equal(modules[0].language_distribution.python, 2);
+  assert.equal(modules[0].language_distribution.go, 1);
+});
+
+test('CD-5: extractSymbols — javascript', () => {
+  const root = makeSandbox();
+  write(root, 'x.js', [
+    'export function login(user) {}',
+    'export class Session {}',
+    'export const TOKEN = 1;',
+    'module.exports.helper = () => {};',
+    'function internalOnly() {}',
+  ].join('\n'));
+  const syms = d.extractSymbols(path.join(root, 'x.js'), 'javascript');
+  assert.ok(syms.includes('login'));
+  assert.ok(syms.includes('Session'));
+  assert.ok(syms.includes('TOKEN'));
+  assert.ok(syms.includes('helper'));
+  assert.ok(!syms.includes('internalOnly'));
+});
+
+test('CD-6: extractSymbols — python', () => {
+  const root = makeSandbox();
+  write(root, 'x.py', [
+    'import os',
+    'def greet(name):',
+    '    pass',
+    'class Auth:',
+    '    def _private(self): pass',
+    'async def fetch(): pass',
+  ].join('\n'));
+  const syms = d.extractSymbols(path.join(root, 'x.py'), 'python');
+  assert.ok(syms.includes('greet'));
+  assert.ok(syms.includes('Auth'));
+  assert.ok(syms.includes('fetch'));
+});
+
+test('CD-7: extractSymbols — go exports only uppercase', () => {
+  const root = makeSandbox();
+  write(root, 'x.go', [
+    'package main',
+    'func Start() {}',
+    'func internal() {}',
+    'type User struct {}',
+    'type privateType int',
+  ].join('\n'));
+  const syms = d.extractSymbols(path.join(root, 'x.go'), 'go');
+  assert.ok(syms.includes('Start'));
+  assert.ok(syms.includes('User'));
+  assert.ok(!syms.includes('internal'));
+  assert.ok(!syms.includes('privateType'));
+});
+
+test('CD-8: extractDeps — javascript imports and requires', () => {
+  const root = makeSandbox();
+  write(root, 'x.js', [
+    'import { readFile } from "node:fs";',
+    'import lodash from "lodash";',
+    'const path = require("node:path");',
+    'const local = require("./local");',
+  ].join('\n'));
+  const deps = d.extractDeps(path.join(root, 'x.js'), 'javascript');
+  assert.ok(deps.includes('node:fs'));
+  assert.ok(deps.includes('lodash'));
+  assert.ok(deps.includes('node:path'));
+  assert.ok(deps.includes('./local'));
+});
+
+test('CD-9: extractDeps — go import block', () => {
+  const root = makeSandbox();
+  write(root, 'x.go', [
+    'package main',
+    'import (',
+    '  "fmt"',
+    '  "net/http"',
+    ')',
+    'import "os"',
+  ].join('\n'));
+  const deps = d.extractDeps(path.join(root, 'x.go'), 'go');
+  assert.ok(deps.includes('fmt'));
+  assert.ok(deps.includes('net/http'));
+  assert.ok(deps.includes('os'));
+});
+
+test('CD-10: buildModuleFacts aggregates symbols and splits internal vs external deps', () => {
+  const root = makeSandbox();
+  write(root, 'src/auth/login.js', [
+    'import { db } from "../db";',
+    'import bcrypt from "bcrypt";',
+    'export function login() {}',
+  ].join('\n'));
+  write(root, 'src/auth/session.js', [
+    'import { cache } from "../cache";',
+    'export class Session {}',
+  ].join('\n'));
+  const files = [
+    { path: 'src/auth/login.js', ext: '.js' },
+    { path: 'src/auth/session.js', ext: '.js' },
+  ];
+  const modules = d.groupFilesIntoModules(files);
+  const facts = d.buildModuleFacts(modules[0], root);
+  assert.ok(facts.symbols.includes('login'));
+  assert.ok(facts.symbols.includes('Session'));
+  assert.ok(facts.internal_deps.includes('../db'));
+  assert.ok(facts.internal_deps.includes('../cache'));
+  assert.ok(facts.external_deps.includes('bcrypt'));
+  assert.equal(facts.file_count, 2);
+});
+
+test('CD-11: buildDocumenterPrompt includes facts JSON and output schema', () => {
+  const facts = {
+    id: 'src-auth',
+    name: 'src/auth',
+    directory: 'src/auth',
+    primary_language: 'javascript',
+    file_count: 2,
+    source_paths: ['src/auth/login.js'],
+    symbols: ['login'],
+    internal_deps: [],
+    external_deps: ['bcrypt'],
+    files: [],
+  };
+  const prompt = d.buildDocumenterPrompt(facts);
+  assert.ok(prompt.includes('np-codebase-documenter'));
+  assert.ok(prompt.includes('"key_concepts"'));
+  assert.ok(prompt.includes('"gotchas"'));
+  assert.ok(prompt.includes('"id": "src-auth"'));
+});
+
+test('CD-12: renderModuleDoc produces frontmatter + body with prose', () => {
+  const facts = {
+    id: 'src-auth',
+    name: 'src/auth',
+    directory: 'src/auth',
+    primary_language: 'javascript',
+    file_count: 1,
+    source_paths: ['src/auth/login.js'],
+    symbols: ['login'],
+    internal_deps: [],
+    external_deps: ['bcrypt'],
+    files: [{ path: 'src/auth/login.js', language: 'javascript', symbols: ['login'], deps: ['bcrypt'] }],
+  };
+  const prose = {
+    description: 'Handles user login flow',
+    purpose: 'Authenticates users via bcrypt hashes.',
+    key_concepts: ['Passwords hashed before compare'],
+    public_api: '`login(credentials)` returns session token.',
+    invariants: ['No plaintext passwords stored'],
+    gotchas: ['bcrypt cost must match production'],
+  };
+  const md = d.renderModuleDoc(facts, prose, { 'src/auth/login.js': 'sha256:abc' });
+  assert.ok(md.startsWith('---\n'));
+  assert.ok(md.includes('name: src/auth'));
+  assert.ok(md.includes('kind: module'));
+  assert.ok(md.includes('description: Handles user login flow'));
+  assert.ok(md.includes('symbols:\n  - login'));
+  assert.ok(md.includes('bcrypt'));
+  assert.ok(md.includes('## Purpose'));
+  assert.ok(md.includes('Authenticates users'));
+  assert.ok(md.includes('## Gotchas'));
+  assert.ok(md.includes('## Files'));
+  assert.ok(md.includes('src/auth/login.js: sha256:abc'));
+});
+
+test('CD-13: renderModuleDoc gracefully handles missing prose', () => {
+  const facts = {
+    id: 'lib',
+    name: 'lib',
+    directory: 'lib',
+    primary_language: 'javascript',
+    file_count: 1,
+    source_paths: ['lib/x.js'],
+    symbols: [],
+    internal_deps: [],
+    external_deps: [],
+    files: [{ path: 'lib/x.js', language: 'javascript', symbols: [], deps: [] }],
+  };
+  const md = d.renderModuleDoc(facts, null, {});
+  assert.ok(md.includes('_TBD'));
+  assert.ok(md.includes('## Files'));
+});
+
+test('CD-14: buildIndexDoc lists modules with counts', () => {
+  const modules = [
+    { id: 'src-auth', directory: 'src/auth', primary_language: 'javascript', file_count: 2 },
+    { id: 'src-billing', directory: 'src/billing', primary_language: 'javascript', file_count: 1 },
+  ];
+  const md = d.buildIndexDoc(modules, { project_name: 'Demo' });
+  assert.ok(md.includes('# Codebase Index'));
+  assert.ok(md.includes('**Project:** Demo'));
+  assert.ok(md.includes('src-auth.md'));
+  assert.ok(md.includes('2 files'));
+  assert.ok(md.includes('1 file'));
+  assert.ok(md.includes('Dev-Agents MUST read'));
+});

package/lib/codebase-manifest.cjs

@@ -0,0 +1,171 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { atomicWriteFileSync, NubosPilotError } = require('./core.cjs');
+
+const SCHEMA_VERSION = 1;
+const CODEBASE_DIR_NAME = 'codebase';
+const MANIFEST_FILENAME = '.hashes.json';
+
+function manifestPath(projectRoot) {
+  return path.join(
+    path.resolve(projectRoot),
+    '.nubos-pilot',
+    CODEBASE_DIR_NAME,
+    MANIFEST_FILENAME,
+  );
+}
+
+function emptyManifest() {
+  return {
+    schema_version: SCHEMA_VERSION,
+    generated_at: null,
+    files: {},
+  };
+}
+
+function readManifest(projectRoot) {
+  const p = manifestPath(projectRoot);
+  let raw;
+  try {
+    raw = fs.readFileSync(p, 'utf-8');
+  } catch (err) {
+    if (err && err.code === 'ENOENT') return emptyManifest();
+    throw new NubosPilotError(
+      'manifest-read-error',
+      `cannot read codebase manifest at ${p}`,
+      { path: p, cause: err && err.code },
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new NubosPilotError(
+      'manifest-parse-error',
+      `codebase manifest is not valid JSON at ${p}`,
+      { path: p, cause: err && err.message },
+    );
+  }
+  if (!parsed || typeof parsed !== 'object') {
+    throw new NubosPilotError(
+      'manifest-invalid-shape',
+      `codebase manifest root is not an object at ${p}`,
+      { path: p },
+    );
+  }
+  if (parsed.schema_version !== SCHEMA_VERSION) {
+    throw new NubosPilotError(
+      'manifest-schema-mismatch',
+      `codebase manifest schema_version ${parsed.schema_version} does not match ${SCHEMA_VERSION}`,
+      { path: p, found: parsed.schema_version, expected: SCHEMA_VERSION },
+    );
+  }
+  if (!parsed.files || typeof parsed.files !== 'object') parsed.files = {};
+  return parsed;
+}
+
+function writeManifest(projectRoot, manifest) {
+  const p = manifestPath(projectRoot);
+  const payload = {
+    schema_version: SCHEMA_VERSION,
+    generated_at: new Date().toISOString(),
+    files: manifest && manifest.files ? manifest.files : {},
+  };
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  atomicWriteFileSync(p, JSON.stringify(payload, null, 2) + '\n');
+  return payload;
+}
+
+function manifestFromScanFiles(scanFiles) {
+  const files = {};
+  for (const f of scanFiles || []) {
+    if (!f || !f.path || !f.sha256) continue;
+    files[f.path] = {
+      sha256: f.sha256,
+      size: typeof f.size === 'number' ? f.size : 0,
+      ext: typeof f.ext === 'string' ? f.ext : '',
+    };
+  }
+  return { schema_version: SCHEMA_VERSION, generated_at: null, files };
+}
+
+function diffManifest(prev, next) {
+  const prevFiles = (prev && prev.files) || {};
+  const nextFiles = (next && next.files) || {};
+  const added = [];
+  const removed = [];
+  const changed = [];
+  const unchanged = [];
+
+  for (const [p, meta] of Object.entries(nextFiles)) {
+    const before = prevFiles[p];
+    if (!before) {
+      added.push({ path: p, sha256: meta.sha256, size: meta.size, ext: meta.ext });
+    } else if (before.sha256 !== meta.sha256) {
+      changed.push({
+        path: p,
+        sha256: meta.sha256,
+        prev_sha256: before.sha256,
+        size: meta.size,
+        ext: meta.ext,
+      });
+    } else {
+      unchanged.push({ path: p, sha256: meta.sha256, size: meta.size, ext: meta.ext });
+    }
+  }
+  for (const [p, meta] of Object.entries(prevFiles)) {
+    if (!nextFiles[p]) {
+      removed.push({ path: p, prev_sha256: meta.sha256 });
+    }
+  }
+
+  added.sort((a, b) => a.path.localeCompare(b.path));
+  removed.sort((a, b) => a.path.localeCompare(b.path));
+  changed.sort((a, b) => a.path.localeCompare(b.path));
+  unchanged.sort((a, b) => a.path.localeCompare(b.path));
+
+  return {
+    added,
+    removed,
+    changed,
+    unchanged,
+    summary: {
+      added: added.length,
+      removed: removed.length,
+      changed: changed.length,
+      unchanged: unchanged.length,
+    },
+  };
+}
+
+function stalePathsForDocs(diff, docIndex) {
+  const touched = new Set();
+  for (const entry of [...(diff.added || []), ...(diff.changed || []), ...(diff.removed || [])]) {
+    touched.add(entry.path);
+  }
+  const staleDocs = new Set();
+  for (const [docId, sources] of Object.entries(docIndex || {})) {
+    if (!Array.isArray(sources)) continue;
+    for (const src of sources) {
+      if (touched.has(src)) {
+        staleDocs.add(docId);
+        break;
+      }
+    }
+  }
+  return {
+    stale_docs: Array.from(staleDocs).sort(),
+    touched_paths: Array.from(touched).sort(),
+  };
+}
+
+module.exports = {
+  SCHEMA_VERSION,
+  manifestPath,
+  emptyManifest,
+  readManifest,
+  writeManifest,
+  manifestFromScanFiles,
+  diffManifest,
+  stalePathsForDocs,
+};

package/lib/codebase-manifest.test.cjs

@@ -0,0 +1,156 @@
+const { test, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const m = require('./codebase-manifest.cjs');
+
+const _sandboxes = [];
+
+function makeSandbox() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'np-cbm-'));
+  _sandboxes.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  while (_sandboxes.length) {
+    const dir = _sandboxes.pop();
+    try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
+  }
+});
+
+test('CM-1: readManifest returns empty manifest when file missing', () => {
+  const root = makeSandbox();
+  const result = m.readManifest(root);
+  assert.equal(result.schema_version, m.SCHEMA_VERSION);
+  assert.deepEqual(result.files, {});
+});
+
+test('CM-2: writeManifest then readManifest roundtrips', () => {
+  const root = makeSandbox();
+  const input = {
+    schema_version: m.SCHEMA_VERSION,
+    files: {
+      'src/a.js': { sha256: 'sha256:aa', size: 10, ext: '.js' },
+      'src/b.py': { sha256: 'sha256:bb', size: 20, ext: '.py' },
+    },
+  };
+  m.writeManifest(root, input);
+  const read = m.readManifest(root);
+  assert.equal(read.schema_version, m.SCHEMA_VERSION);
+  assert.equal(read.files['src/a.js'].sha256, 'sha256:aa');
+  assert.equal(read.files['src/b.py'].size, 20);
+  assert.ok(read.generated_at);
+});
+
+test('CM-3: manifestPath places file at .nubos-pilot/codebase/.hashes.json', () => {
+  const root = makeSandbox();
+  const p = m.manifestPath(root);
+  assert.equal(p, path.join(root, '.nubos-pilot', 'codebase', '.hashes.json'));
+});
+
+test('CM-4: manifestFromScanFiles converts scan files[] to manifest shape', () => {
+  const scanFiles = [
+    { path: 'src/a.js', sha256: 'sha256:11', size: 5, ext: '.js' },
+    { path: 'src/b.py', sha256: 'sha256:22', size: 7, ext: '.py' },
+    { path: 'no-hash.bin' },
+  ];
+  const manifest = m.manifestFromScanFiles(scanFiles);
+  assert.equal(manifest.schema_version, m.SCHEMA_VERSION);
+  assert.equal(Object.keys(manifest.files).length, 2);
+  assert.equal(manifest.files['src/a.js'].sha256, 'sha256:11');
+  assert.equal(manifest.files['src/b.py'].ext, '.py');
+});
+
+test('CM-5: diffManifest detects added, removed, changed, unchanged', () => {
+  const prev = {
+    schema_version: 1,
+    files: {
+      'kept.js': { sha256: 'sha256:a', size: 1, ext: '.js' },
+      'changed.js': { sha256: 'sha256:old', size: 1, ext: '.js' },
+      'removed.js': { sha256: 'sha256:r', size: 1, ext: '.js' },
+    },
+  };
+  const next = {
+    schema_version: 1,
+    files: {
+      'kept.js': { sha256: 'sha256:a', size: 1, ext: '.js' },
+      'changed.js': { sha256: 'sha256:new', size: 2, ext: '.js' },
+      'added.js': { sha256: 'sha256:n', size: 1, ext: '.js' },
+    },
+  };
+  const diff = m.diffManifest(prev, next);
+  assert.deepEqual(diff.added.map((x) => x.path), ['added.js']);
+  assert.deepEqual(diff.removed.map((x) => x.path), ['removed.js']);
+  assert.deepEqual(diff.changed.map((x) => x.path), ['changed.js']);
+  assert.deepEqual(diff.unchanged.map((x) => x.path), ['kept.js']);
+  assert.equal(diff.changed[0].prev_sha256, 'sha256:old');
+  assert.equal(diff.changed[0].sha256, 'sha256:new');
+  assert.deepEqual(diff.summary, { added: 1, removed: 1, changed: 1, unchanged: 1 });
+});
+
+test('CM-6: diffManifest handles empty prev (bootstrap case)', () => {
+  const next = {
+    schema_version: 1,
+    files: {
+      'a.js': { sha256: 'sha256:a', size: 1, ext: '.js' },
+      'b.js': { sha256: 'sha256:b', size: 1, ext: '.js' },
+    },
+  };
+  const diff = m.diffManifest(m.emptyManifest(), next);
+  assert.equal(diff.summary.added, 2);
+  assert.equal(diff.summary.removed, 0);
+  assert.equal(diff.summary.changed, 0);
+  assert.equal(diff.summary.unchanged, 0);
+});
+
+test('CM-7: readManifest throws on schema mismatch', () => {
+  const root = makeSandbox();
+  const p = m.manifestPath(root);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify({ schema_version: 99, files: {} }));
+  assert.throws(
+    () => m.readManifest(root),
+    (err) => err.code === 'manifest-schema-mismatch',
+  );
+});
+
+test('CM-8: readManifest throws on invalid JSON', () => {
+  const root = makeSandbox();
+  const p = m.manifestPath(root);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, '{not json');
+  assert.throws(
+    () => m.readManifest(root),
+    (err) => err.code === 'manifest-parse-error',
+  );
+});
+
+test('CM-9: stalePathsForDocs flags docs whose sources changed', () => {
+  const diff = {
+    added: [{ path: 'new.js' }],
+    changed: [{ path: 'src/auth/login.js' }],
+    removed: [],
+  };
+  const docIndex = {
+    'modules/auth.md': ['src/auth/login.js', 'src/auth/session.js'],
+    'modules/billing.md': ['src/billing/invoice.js'],
+    'modules/shared.md': ['new.js'],
+  };
+  const result = m.stalePathsForDocs(diff, docIndex);
+  assert.deepEqual(result.stale_docs, ['modules/auth.md', 'modules/shared.md']);
+  assert.ok(result.touched_paths.includes('src/auth/login.js'));
+  assert.ok(result.touched_paths.includes('new.js'));
+});
+
+test('CM-10: writeManifest is atomic and creates codebase dir', () => {
+  const root = makeSandbox();
+  const result = m.writeManifest(root, {
+    files: { 'x.js': { sha256: 'sha256:x', size: 1, ext: '.js' } },
+  });
+  const p = m.manifestPath(root);
+  assert.ok(fs.existsSync(p));
+  assert.equal(result.files['x.js'].sha256, 'sha256:x');
+});

package/lib/git.cjs

@@ -193,6 +193,43 @@ function gitDiffNoColor(ref, filepath) {
   }
 }
 
+function workspaceGitInfo(cwd) {
+  const exec = (args) => {
+    try {
+      return execFileSync('git', args, {
+        cwd,
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 5000,
+        encoding: 'utf-8',
+      }).trim();
+    } catch {
+      return null;
+    }
+  };
+
+  const isRepoProbe = exec(['rev-parse', '--is-inside-work-tree']);
+  if (isRepoProbe !== 'true') return { is_repo: false };
+
+  const current_branch = exec(['rev-parse', '--abbrev-ref', 'HEAD']) || null;
+  const remote = exec(['config', '--get', 'remote.origin.url']) || null;
+  const branchesRaw = exec(['for-each-ref', '--format=%(refname:short)', 'refs/heads/']) || '';
+  const branches = branchesRaw.split('\n').filter(Boolean);
+  const commitsRaw = exec(['log', '--pretty=format:%h|%an|%ad|%s', '--date=short', '-n', '20']) || '';
+  const commits = commitsRaw.split('\n').filter(Boolean).map((line) => {
+    const idx1 = line.indexOf('|');
+    const idx2 = line.indexOf('|', idx1 + 1);
+    const idx3 = line.indexOf('|', idx2 + 1);
+    if (idx1 < 0 || idx2 < 0 || idx3 < 0) return { raw: line };
+    return {
+      sha: line.slice(0, idx1),
+      author: line.slice(idx1 + 1, idx2),
+      date: line.slice(idx2 + 1, idx3),
+      subject: line.slice(idx3 + 1),
+    };
+  });
+  return { is_repo: true, current_branch, remote, branches, commits };
+}
+
 module.exports = {
   commitTask,
   assertCommittablePaths,
@@ -204,4 +241,5 @@ module.exports = {
   listTaskCommits,
   gitShowSafe,
   gitDiffNoColor,
+  workspaceGitInfo,
 };