gittable 1.0.0

package/commands/uninit.js

@@ -0,0 +1,57 @@
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const { isGitRepo } = require('../lib/git/exec');
+const { showBanner } = require('../lib/ui/banner');
+const fs = require('node:fs');
+const path = require('node:path');
+
+module.exports = async (args) => {
+  showBanner('UNINIT');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Remove Git Repository')}`);
+
+  if (!isGitRepo()) {
+    clack.cancel(chalk.yellow('Not a git repository'));
+    return;
+  }
+
+  const force = args.includes('--force') || args.includes('-f');
+  const gitDir = path.join(process.cwd(), '.git');
+
+  if (!force) {
+    const confirm = await clack.confirm({
+      message: chalk.red('This will permanently delete all git history. Continue?'),
+      initialValue: false,
+    });
+
+    if (clack.isCancel(confirm) || !confirm) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const spinner = clack.spinner();
+  spinner.start('Removing git repository');
+
+  try {
+    // Check if .git is a file (submodule) or directory
+    const gitStat = fs.statSync(gitDir);
+
+    if (gitStat.isFile()) {
+      // It's a submodule - just remove the file
+      fs.unlinkSync(gitDir);
+    } else if (gitStat.isDirectory()) {
+      // Remove the entire .git directory
+      fs.rmSync(gitDir, { recursive: true, force: true });
+    }
+
+    spinner.stop();
+    clack.outro(
+      chalk.green.bold('Git repository removed. You can now run "gittable init" for a fresh start.')
+    );
+  } catch (error) {
+    spinner.stop();
+    clack.cancel(chalk.red('Failed to remove git repository'));
+    console.error(error.message);
+    process.exit(1);
+  }
+};

package/index.d.ts

@@ -0,0 +1,56 @@
+declare module 'gittable' {
+  export interface CommitType {
+    value: string;
+    name: string;
+  }
+
+  export interface Scope {
+    name: string;
+  }
+
+  export interface Config {
+    types: CommitType[];
+    scopes?: Scope[];
+    scopeOverrides?: Record<string, Scope[]>;
+
+    allowTicketNumber?: boolean;
+    isTicketNumberRequired?: boolean;
+    ticketNumberPrefix?: string;
+    ticketNumberSuffix?: string;
+    ticketNumberRegExp?: string;
+    fallbackTicketNumber?: string;
+    prependTicketToHead?: boolean;
+
+    allowCustomScopes?: boolean;
+    allowBreakingChanges?: string[];
+    skipQuestions?: string[];
+    skipEmptyScopes?: boolean;
+
+    subjectLimit?: number;
+    subjectSeparator?: string;
+    typePrefix?: string;
+    typeSuffix?: string;
+    upperCaseSubject?: boolean;
+
+    breaklineChar?: string;
+    breakingPrefix?: string;
+    footerPrefix?: string;
+
+    usePreparedCommit?: boolean;
+    askForBreakingChangeFirst?: boolean;
+  }
+
+  export interface Answers {
+    type: string;
+    scope: string | null;
+    ticketNumber?: string;
+    subject: string;
+    body?: string;
+    breaking?: string;
+    footer?: string;
+  }
+
+  export type Prompter = (cz: unknown, commit: (message: string) => void) => Promise<void>;
+
+  export const prompter: Prompter;
+}

package/index.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const { promptQuestions } = require('./lib/commit/questions');
+const buildCommit = require('./lib/commit/build-commit');
+const readConfigFile = require('./lib/config/read-config-file');
+
+const prompter = async (_, commit) => {
+  const config = readConfigFile();
+  if (!config) process.exit(1);
+
+  config.subjectLimit = config.subjectLimit || 100;
+
+  try {
+    const answers = await promptQuestions(config);
+    const message = buildCommit(answers, config);
+
+    clack.note(message, chalk.bold('Commit Preview'));
+
+    const action = await clack.select({
+      message: chalk.yellow('Proceed?'),
+      options: [
+        { value: 'yes', label: chalk.green('Commit') },
+        { value: 'no', label: chalk.red('Cancel') },
+      ],
+    });
+
+    if (clack.isCancel(action) || action === 'no') {
+      clack.cancel(chalk.yellow('Cancelled'));
+      process.exit(0);
+    }
+
+    const spinner = clack.spinner();
+    spinner.start('Creating commit');
+
+    await new Promise((resolve, reject) => {
+      try {
+        commit(message);
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+
+    spinner.stop('Commit created');
+    clack.outro(chalk.green.bold('Success'));
+  } catch (error) {
+    clack.cancel(chalk.red('Failed'));
+    console.error(error);
+    process.exit(1);
+  }
+};
+
+module.exports = { prompter };

package/lib/commit/build-commit.js

@@ -0,0 +1,64 @@
+const wrap = require('word-wrap');
+
+const DEFAULTS = {
+  separator: ': ',
+  maxWidth: 100,
+  breakChar: '|',
+};
+
+const wrapText = (text, width = DEFAULTS.maxWidth) =>
+  text ? wrap(text, { trim: true, newline: '\n', indent: '', width }) : '';
+
+const escapeChars = (str) => str.replace(/[`"\\$!<>&]/g, (char) => `\\${char}`);
+
+const addBreaklines = (text, char = DEFAULTS.breakChar) => text.split(char).join('\n');
+
+const buildCommit = (answers, config) => {
+  const parts = [];
+
+  // Build header: type(scope): subject
+  let header = config.typePrefix || '';
+  header += answers.type;
+  header += config.typeSuffix || '';
+
+  if (answers.scope) {
+    header += `(${answers.scope})`;
+  }
+
+  header += config.subjectSeparator || DEFAULTS.separator;
+
+  if (config.prependTicketToHead && answers.ticketNumber) {
+    const ticket = answers.ticketNumber.trim();
+    const prefix = config.ticketNumberPrefix || '';
+    const suffix = config.ticketNumberSuffix || '';
+    header = `${prefix}${ticket}${suffix} ${header}`;
+  }
+
+  header += answers.subject.slice(0, config.subjectLimit || 100);
+
+  parts.push(header);
+
+  // Add body
+  if (answers.body) {
+    const body = wrapText(addBreaklines(answers.body, config.breaklineChar));
+    parts.push('', body);
+  }
+
+  // Add breaking changes
+  if (answers.breaking) {
+    const prefix = config.breakingPrefix || 'BREAKING CHANGE:';
+    const breaking = wrapText(answers.breaking);
+    parts.push('', `${prefix}\n${breaking}`);
+  }
+
+  // Add footer
+  if (answers.footer) {
+    const prefix = config.footerPrefix === '' ? '' : config.footerPrefix || 'ISSUES CLOSED:';
+    const footer = wrapText(addBreaklines(answers.footer, config.breaklineChar));
+    parts.push('', prefix ? `${prefix} ${footer}` : footer);
+  }
+
+  return escapeChars(parts.join('\n'));
+};
+
+module.exports = buildCommit;

package/lib/commit/get-previous-commit.js

@@ -0,0 +1,15 @@
+const fs = require('node:fs');
+
+const getPreviousCommit = () => {
+  const path = './.git/COMMIT_EDITMSG';
+  if (!fs.existsSync(path)) return null;
+
+  return fs
+    .readFileSync(path, 'utf-8')
+    .replace(/^#.*/gm, '')
+    .replace(/^\s*[\r\n]/gm, '')
+    .replace(/[\r\n]$/, '')
+    .split(/\r\n|\r|\n/);
+};
+
+module.exports = getPreviousCommit;

package/lib/commit/questions.js

@@ -0,0 +1,226 @@
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const _fs = require('node:fs');
+const getPreviousCommit = require('./get-previous-commit');
+
+// Constants
+const SCOPE_CATEGORIES = {
+  'Core App Structure': ['app', 'routing', 'layout', 'middleware'],
+
+  'Rendering & Runtime': ['rsc', 'client', 'server'],
+
+  'UI & Shared Logic': ['components', 'styles', 'hooks', 'utils', 'types'],
+
+  'Data & API': ['api', 'auth', 'db', 'cache'],
+
+  'Dev & Tooling': ['config', 'logging', 'test'],
+
+  Infrastructure: ['infra', 'env'],
+};
+
+const categorizeScopesOptimized = (scopes) => {
+  const result = {};
+  const uncategorized = [];
+
+  // Initialize categories
+  for (const cat of Object.keys(SCOPE_CATEGORIES)) {
+    result[cat] = [];
+  }
+
+  // Build lookup map for O(1) categorization
+  const lookup = new Map();
+  for (const [cat, scopeNames] of Object.entries(SCOPE_CATEGORIES)) {
+    for (const name of scopeNames) {
+      lookup.set(name, cat);
+    }
+  }
+
+  // Categorize scopes
+  for (const scope of scopes) {
+    const name = typeof scope === 'string' ? scope : scope.name;
+    const category = lookup.get(name);
+
+    if (category) {
+      result[category].push(scope);
+    } else {
+      uncategorized.push(scope);
+    }
+  }
+
+  if (uncategorized.length > 0) {
+    result.Other = uncategorized;
+  }
+
+  // Remove empty categories
+  return Object.fromEntries(Object.entries(result).filter(([_, scopes]) => scopes.length > 0));
+};
+
+const handleCancel = () => {
+  clack.cancel(chalk.yellow('Operation cancelled'));
+  process.exit(0);
+};
+
+const createValidator = (config, field) => {
+  const validators = {
+    ticket: (value) => {
+      if (!value && config.isTicketNumberRequired && !config.fallbackTicketNumber) {
+        return 'Ticket number is required';
+      }
+      if (value && config.ticketNumberRegExp) {
+        const regex = new RegExp(config.ticketNumberRegExp);
+        if (!regex.test(value)) {
+          return `Must match pattern: ${config.ticketNumberRegExp}`;
+        }
+      }
+    },
+    subject: (value) => {
+      if (!value) return 'Subject is required';
+      const limit = config.subjectLimit || 100;
+      if (value.length > limit) {
+        return chalk.red(`Exceeds ${limit} chars (current: ${value.length})`);
+      }
+    },
+  };
+
+  return validators[field];
+};
+
+// Main prompt function
+async function promptQuestions(config) {
+  // Optimize scope handling
+  const scopes = config.scopeOverrides || config.scopes || [];
+  const categorizedScopes = scopes.length ? categorizeScopesOptimized(scopes) : null;
+
+  // Use clack.group for better performance and UX
+  const answers = await clack.group(
+    {
+      type: () =>
+        clack.select({
+          message: chalk.cyan('Select commit type:'),
+          options: config.types.map((t) => ({
+            value: t.value,
+            label: t.name,
+            hint: t.value,
+          })),
+        }),
+
+      scopeCategory: ({ results }) => {
+        if (!categorizedScopes || results.type === 'wip') return Promise.resolve(null);
+
+        const categories = Object.keys(categorizedScopes);
+        const options = categories.map((cat) => ({
+          value: cat,
+          label: cat,
+          hint: `${categorizedScopes[cat].length} scopes`,
+        }));
+
+        options.push(
+          { value: '__empty__', label: chalk.dim('No scope') },
+          { value: '__custom__', label: chalk.dim('Custom scope') }
+        );
+
+        return clack.select({
+          message: chalk.cyan('Select scope category:'),
+          options,
+        });
+      },
+
+      scope: ({ results }) => {
+        if (!results.scopeCategory || results.scopeCategory === '__empty__') {
+          return Promise.resolve(null);
+        }
+
+        if (results.scopeCategory === '__custom__') {
+          return clack.text({
+            message: chalk.cyan('Enter custom scope:'),
+            placeholder: 'e.g., auth, api, ui',
+          });
+        }
+
+        const categoryScopes = categorizedScopes[results.scopeCategory];
+        return clack.select({
+          message: chalk.cyan('Select scope:'),
+          options: categoryScopes.map((s) => {
+            const name = typeof s === 'string' ? s : s.name;
+            return { value: name, label: name };
+          }),
+        });
+      },
+
+      ticketNumber: () => {
+        if (!config.allowTicketNumber) return Promise.resolve('');
+
+        return clack.text({
+          message: chalk.cyan('Ticket number:'),
+          placeholder: config.ticketNumberPrefix || 'TICKET-',
+          defaultValue: config.fallbackTicketNumber || '',
+          validate: createValidator(config, 'ticket'),
+        });
+      },
+
+      subject: () => {
+        const previous = getPreviousCommit();
+        const defaultValue = (config.usePreparedCommit && previous?.[0]) || '';
+
+        return clack.text({
+          message: chalk.cyan('Commit message:'),
+          placeholder: 'add user authentication',
+          defaultValue,
+          validate: createValidator(config, 'subject'),
+        });
+      },
+
+      body: () => {
+        if (config.skipQuestions?.includes('body')) return Promise.resolve('');
+
+        const previous = getPreviousCommit();
+        const defaultValue =
+          config.usePreparedCommit && previous?.length > 1 ? previous.slice(1).join('|') : '';
+
+        return clack.text({
+          message: chalk.cyan('Extended description (optional):'),
+          placeholder: 'Use "|" for new lines',
+          defaultValue,
+        });
+      },
+
+      breaking: ({ results }) => {
+        const shouldAsk =
+          config.askForBreakingChangeFirst || config.allowBreakingChanges?.includes(results.type);
+
+        if (!shouldAsk) return Promise.resolve('');
+
+        return clack.text({
+          message: chalk.red('Breaking changes (optional):'),
+          placeholder: 'Describe breaking changes',
+        });
+      },
+
+      footer: ({ results }) => {
+        if (results.type === 'wip' || config.skipQuestions?.includes('footer')) {
+          return Promise.resolve('');
+        }
+
+        return clack.text({
+          message: chalk.cyan('Issues closed (optional):'),
+          placeholder: '#31, #34',
+        });
+      },
+    },
+    {
+      onCancel: handleCancel,
+    }
+  );
+
+  // Process subject casing
+  if (answers.subject) {
+    const shouldUpperCase = config.upperCaseSubject || false;
+    answers.subject = shouldUpperCase
+      ? answers.subject.charAt(0).toUpperCase() + answers.subject.slice(1)
+      : answers.subject.charAt(0).toLowerCase() + answers.subject.slice(1);
+  }
+
+  return answers;
+}
+
+module.exports = { promptQuestions };

package/lib/config/read-config-file.js

@@ -0,0 +1,54 @@
+const findConfig = require('find-config');
+const path = require('node:path');
+const chalk = require('chalk');
+const log = require('../utils/logger');
+
+const CONFIG_NAMES = ['.gittable.js', '.gittable.json'];
+
+const showError = () => {
+  console.log();
+  log.error(chalk.red.bold('No configuration found!'));
+  console.log();
+  console.log(chalk.yellow('  Create one of:'));
+  for (const name of CONFIG_NAMES) {
+    console.log(chalk.cyan(`    • ${name}`));
+  }
+  console.log(chalk.cyan('    • package.json config'));
+  console.log();
+  console.log(chalk.gray('  Docs: github.com/leonardoanalista/cz-customizable'));
+  console.log();
+};
+
+const readConfigFile = () => {
+  // Try .cz-config.js
+  const jsConfig = findConfig.require(CONFIG_NAMES[0], { home: false });
+  if (jsConfig) {
+    log.success(chalk.green(`Using: ${chalk.bold(CONFIG_NAMES[0])}`));
+    return jsConfig;
+  }
+
+  // Try .cz-config.json
+  const jsonConfig = findConfig.require(CONFIG_NAMES[1], { home: false });
+  if (jsonConfig) {
+    log.success(chalk.green(`Using: ${chalk.bold(CONFIG_NAMES[1])}`));
+    return jsonConfig;
+  }
+
+  // Try package.json
+  const pkgPath = findConfig('package.json', { home: false });
+  if (pkgPath) {
+    const pkg = require(pkgPath);
+    const configPath = pkg.config?.['cz-customizable']?.config;
+
+    if (configPath) {
+      const fullPath = path.resolve(path.dirname(pkgPath), configPath);
+      log.success(chalk.green(`Using: ${chalk.bold(fullPath)}`));
+      return require(fullPath);
+    }
+  }
+
+  showError();
+  return null;
+};
+
+module.exports = readConfigFile;