ai-ship-cli 0.1.0-beta.1

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "ai-ship-cli",
+  "version": "0.1.0-beta.1",
+  "description": "AI-powered Git workflow CLI (commit, branch, PR generation)",
+  "main": "dist/index.js",
+  "bin": {
+    "ai-ship": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "ts-node src/index.ts",
+    "format": "prettier --write .",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "git",
+    "cli",
+    "ai",
+    "commit",
+    "developer-tools",
+    "productivity"
+  ],
+  "author": "Diganta Kr Banik",
+  "license": "ISC",
+  "dependencies": {
+    "@google/genai": "^1.44.0",
+    "chalk": "^4.1.2",
+    "dotenv": "^17.3.1",
+    "enquirer": "^2.4.1",
+    "inquirer": "^8.2.7",
+    "lodash": "^4.17.23",
+    "minimatch": "^10.2.4",
+    "minimist": "^1.2.8",
+    "ora": "^5.4.1"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^8.2.12",
+    "@types/minimist": "^1.2.5",
+    "@types/node": "^25.3.5",
+    "prettier": "^3.8.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}

package/src/ai/gemini.ts

@@ -0,0 +1,27 @@
+import { GoogleGenAI } from '@google/genai';
+import { getCurrentConfig, saveValueToConfig } from '../utils/helper';
+import { askApiKey } from '../utils/inputs';
+import chalk from 'chalk';
+const GEMINI_API_KEY = process.env.GEMINI_API_KEY;
+let apiKey = getCurrentConfig('geminiApiKey') || GEMINI_API_KEY;
+
+let ai = new GoogleGenAI({ apiKey });
+export const generateWithGemini = async (prompt: string) => {
+  try {
+    if (!apiKey) {
+      console.log('Gemini API key not found.');
+      apiKey = await askApiKey();
+      saveValueToConfig('geminiApiKey', apiKey);
+      ai = new GoogleGenAI({ apiKey });
+      console.log('API key saved!');
+    }
+    const response = await ai.models.generateContent({
+      model: 'gemini-2.5-flash',
+      contents: prompt,
+    });
+    return response.text || '';
+  } catch (err) {
+    console.log(chalk.red(`We ran into an error: ${chalk.bold.red(err)}`));
+    return '';
+  }
+};

package/src/ai/ollama.ts

@@ -0,0 +1,38 @@
+import chalk from 'chalk';
+import { getCurrentConfig } from '../utils/helper';
+
+export const generateWithGemma = async (prompt: string) => {
+  try {
+    const endpoint = getCurrentConfig('localEndpoint') || 'http://127.0.0.1:11434';
+    const model = getCurrentConfig('model') || 'gemma:2b';
+
+    const res = await fetch(`${endpoint}/api/generate`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: model,
+        prompt,
+        stream: false,
+        options: {
+          temperature: 0.1,
+        },
+      }),
+    });
+
+    const data = await res.json();
+
+    if (!res.ok || data.error) {
+      throw new Error(data.error || `HTTP error! status: ${res.status}`);
+    }
+
+    if (data.response) {
+      return data.response.trim();
+    }
+
+    throw new Error('Unexpected response format from local model');
+  } catch (e) {
+    throw new Error(`Failed to connect to local model: ${(e as Error).message}`);
+  }
+};

package/src/analyzers/analyzer.ts

@@ -0,0 +1,117 @@
+import { detectSignals } from './detectSignals';
+import analyzeMarkup from './markupAnalyzer';
+import analyzeConfig from './configAnalyzer';
+
+type DiffSummary = {
+  file: string;
+  additions: number;
+  deletions: number;
+  signals: string[];
+  snippet: string[];
+};
+
+const CODE_EXT = [
+  '.js',
+  '.ts',
+  '.jsx',
+  '.tsx',
+  '.py',
+  '.java',
+  '.go',
+  '.rs',
+  '.cpp',
+  '.c',
+  '.h',
+  '.hpp',
+  '.cs',
+  '.php',
+  '.rb',
+];
+
+const MARKUP_EXT = ['.html', '.css', '.scss', '.less'];
+
+const CONFIG_EXT = ['.json', '.yaml', '.yml', '.toml'];
+
+const getFileType = (file: string) => {
+  const lower = file.toLowerCase();
+
+  if (CODE_EXT.some((ext) => lower.endsWith(ext))) return 'code';
+
+  if (MARKUP_EXT.some((ext) => lower.endsWith(ext))) return 'markup';
+
+  if (
+    CONFIG_EXT.some((ext) => lower.endsWith(ext)) ||
+    lower === 'dockerfile' ||
+    lower.includes('package.json')
+  )
+    return 'config';
+
+  return 'other';
+};
+
+export const analyzeDiff = (diff: string): DiffSummary[] => {
+  try {
+    const files = diff.split('diff --git').filter(Boolean);
+
+    const summaries: DiffSummary[] = [];
+
+    for (const chunk of files) {
+      const lines = chunk.split('\n');
+
+      const fileMatch = lines[0]?.match(/a\/(.+?) b\/(.+)/);
+      const file = fileMatch?.[2] || 'unknown';
+
+      const fileType = getFileType(file);
+
+      if (fileType === 'markup') {
+        summaries.push(analyzeMarkup(file, lines));
+        continue;
+      }
+
+      if (fileType === 'config') {
+        summaries.push(analyzeConfig(file, lines));
+        continue;
+      }
+
+      // default = code analyzer
+      let additions = 0;
+      let deletions = 0;
+
+      const snippet: string[] = [];
+      const signals: string[] = [];
+
+      for (const line of lines) {
+        if (line.startsWith('+') && !line.startsWith('+++')) {
+          additions++;
+
+          const code = line.slice(1).trim();
+
+          if (snippet.length < 20) snippet.push(`+ ${code}`);
+
+          detectSignals(code, signals);
+        }
+
+        if (line.startsWith('-') && !line.startsWith('---')) {
+          deletions++;
+
+          const code = line.slice(1).trim();
+
+          if (snippet.length < 20) snippet.push(`- ${code}`);
+        }
+      }
+
+      summaries.push({
+        file,
+        additions,
+        deletions,
+        signals: [...new Set(signals)],
+        snippet,
+      });
+    }
+
+    return summaries;
+  } catch (e) {
+    console.log({ e });
+    return [];
+  }
+};

package/src/analyzers/compressBranchSummary.ts

@@ -0,0 +1,16 @@
+type DiffSummary = {
+  file: string;
+  additions: number;
+  deletions: number;
+  signals: string[];
+  snippet: string[];
+};
+
+export const compressBranchSummary = (summary: DiffSummary[]) => {
+  return summary
+    .slice(0, 8) // limit files
+    .map((s) => ({
+      file: s.file,
+      signals: s.signals,
+    }));
+};

package/src/analyzers/configAnalyzer.ts

@@ -0,0 +1,17 @@
+export default (file: string, lines: string[]) => {
+  const snippet: string[] = [];
+
+  for (const line of lines) {
+    if (line.startsWith('+') || line.startsWith('-')) {
+      if (snippet.length < 30) snippet.push(line);
+    }
+  }
+
+  return {
+    file,
+    additions: snippet.filter((l) => l.startsWith('+')).length,
+    deletions: snippet.filter((l) => l.startsWith('-')).length,
+    signals: ['config updated'],
+    snippet,
+  };
+};

package/src/analyzers/detectSignals.ts

@@ -0,0 +1,13 @@
+export const detectSignals = (line: string, signals: string[]) => {
+  if (/function\s+\w+/.test(line)) signals.push('function added');
+
+  if (/class\s+\w+/.test(line)) signals.push('class added');
+
+  if (/import\s+/.test(line)) signals.push('imports updated');
+
+  if (/export\s+/.test(line)) signals.push('exports updated');
+
+  if (/FROM\s+/.test(line)) signals.push('docker base image change');
+
+  if (/version/.test(line)) signals.push('version updated');
+};

package/src/analyzers/markupAnalyzer.ts

@@ -0,0 +1,25 @@
+export default (file: string, lines: string[]) => {
+  const snippet: string[] = [];
+  let additions = 0;
+  let deletions = 0;
+
+  for (const line of lines) {
+    if (line.startsWith('+') && !line.startsWith('+++')) {
+      additions++;
+      if (snippet.length < 20) snippet.push(line);
+    }
+
+    if (line.startsWith('-') && !line.startsWith('---')) {
+      deletions++;
+      if (snippet.length < 20) snippet.push(line);
+    }
+  }
+
+  return {
+    file,
+    additions,
+    deletions,
+    signals: ['markup updated'],
+    snippet,
+  };
+};

package/src/commands/commit.ts

@@ -0,0 +1,18 @@
+import ora from 'ora';
+import startWorkflow from './git/startWorkflow';
+import { stageAll, stageFiles } from '../utils/git';
+
+export default async (payload: string[] = [], flags: any = {}) => {
+  const stageSpinner = ora('Staging files...').start();
+  if (payload.length > 0) {
+    await stageFiles(payload);
+    stageSpinner.succeed(`Staged ${payload.length} specified file(s).`);
+  } else {
+    await stageAll();
+    stageSpinner.succeed('Staged all changes.');
+  }
+
+  console.log('');
+
+  await startWorkflow(flags);
+};

package/src/commands/config.ts

@@ -0,0 +1,73 @@
+import chalk from 'chalk';
+import {
+  deleteConfigKey,
+  getCurrentConfig,
+  jsonConfig,
+  log,
+  saveValueToConfig,
+  verboseConfig,
+} from '../utils/helper';
+import { askApiKey } from '../utils/inputs';
+import type { ParsedArgs } from 'minimist';
+type AIShipConfig = Record<string, any>;
+export default async (args: ParsedArgs) => {
+  // `args` now contains elegantly parsed flags from minimist!
+  // Example: `--model --local connection.json` becomes `{ model: true, local: 'connection.json' }`
+  // Example: `--user-model local` becomes `{ 'user-model': 'local' }`
+  const subCommand = args._[0];
+  if (subCommand === 'show') {
+    const currenConfigs = getCurrentConfig();
+    if (args['verbose']) {
+      verboseConfig(currenConfigs);
+    } else if (args['json']) {
+      jsonConfig(currenConfigs);
+    }
+    return;
+  }
+
+  if (subCommand === 'set') {
+    const key = args._[1];
+    const value = args._[2];
+
+    if (!key || !value) {
+      console.log('Usage: ai-ship config set <key> <value>');
+      return;
+    }
+
+    saveValueToConfig(key, value);
+    return;
+  }
+
+  if (subCommand === 'get') {
+    const key = args._[1];
+
+    if (!key) {
+      console.log(chalk.yellow('Usage: ai-ship config get <key>'));
+      return;
+    }
+
+    const configValue = getCurrentConfig(key);
+
+    if (configValue === undefined || configValue === null || configValue === '') {
+      console.log(chalk.red(`Config "${key}" not found.`));
+      return;
+    }
+
+    console.log(`${chalk.cyan(key)}: ${chalk.green(JSON.stringify(configValue, null, 2))}`);
+    return;
+  }
+  if (args['add-key']) {
+    const apiKey = await askApiKey();
+    saveValueToConfig('geminiApiKey', apiKey);
+    log('API key saved!');
+  } else if (args['delete-key']) {
+    if (deleteConfigKey('geminiApiKey')) {
+      log(chalk.green('API Key Deleted'));
+    } else {
+      log(chalk.red('API Key Could Not Be Deleted. API KEY NOT FOUND!'));
+    }
+  } else {
+    log(chalk.yellow('Unrecognized config option. Here are the extracted args for your logic:'));
+    console.log(args);
+  }
+};

package/src/commands/git/startCheckout.ts

@@ -0,0 +1,97 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { generateAIResponse, getBranchPrompt } from '../../utils/ai';
+import { interactiveRefinePrompt } from '../../utils/inquirer';
+import { gitCheckoutNewBranch, gitRenameBranch } from '../../utils/git';
+
+type BranchParams = {
+  branchSummary: any[];
+  allBranches: string[];
+  currentBranch: string;
+  commitMessage: string;
+  provider: string;
+  flags?: any;
+};
+
+export default async ({
+  branchSummary,
+  allBranches,
+  currentBranch,
+  commitMessage,
+  provider,
+  flags = {},
+}: BranchParams) => {
+  let branchName = '';
+  let branchAccepted = false;
+
+  const sanitizeBranchName = (name: string) => {
+    return name
+      .toLowerCase()
+      .replace(/['"]/g, '')
+      .replace(/\\s+/g, '-')
+      .replace(/[^a-z0-9\\-\\/]/g, '')
+      .replace(/--+/g, '-')
+      .trim();
+  };
+
+  const branchPrompt = getBranchPrompt(
+    provider,
+    branchSummary,
+    allBranches,
+    currentBranch,
+    commitMessage,
+  );
+  const allBranchesSet = new Set(allBranches);
+
+  while (!branchAccepted) {
+    const branchSpinner = ora('Generating branch name...').start();
+
+    const rawBranch = await generateAIResponse(provider, branchPrompt);
+
+    branchName = sanitizeBranchName(rawBranch);
+
+    // ensure branch prefix exists
+    if (!branchName.includes('/')) {
+      branchName = `feature/${branchName}`;
+    }
+
+    // avoid branch collision
+    let finalBranch = branchName;
+    let counter = 1;
+
+    while (allBranchesSet.has(finalBranch)) {
+      finalBranch = `${branchName}-${counter++}`;
+    }
+
+    branchName = finalBranch;
+
+    branchSpinner.succeed('Branch name generated:\\n');
+
+    console.log(chalk.magenta(branchName));
+    console.log('');
+
+    // auto accept if --yes
+    if (flags?.yes) {
+      branchAccepted = true;
+      break;
+    }
+
+    const result = await interactiveRefinePrompt('branch name', branchName);
+    if (result.cancel) return;
+
+    branchAccepted = result.accepted;
+    branchName = sanitizeBranchName(result.value);
+  }
+
+  // dry run support
+  if (flags?.['dry-run']) {
+    console.log(chalk.yellow('Dry run enabled. Branch not created.\n'));
+    return;
+  }
+
+  const branchProcessSpinner = ora('Applying branch name...').start();
+
+  await gitCheckoutNewBranch(branchName);
+
+  branchProcessSpinner.succeed(`Checked out to ${chalk.bold(branchName)}!`);
+};

package/src/commands/git/startCommit.ts

@@ -0,0 +1,108 @@
+import chalk from 'chalk';
+import { getProvider, log } from '../../utils/helper';
+import { getFilesChanged, getStagedDiff, gitCommit, unstageFiles } from '../../utils/git';
+import { expandDirectories } from '../../utils/files';
+import { filterNoiseFiles } from '../../utils/parser';
+import { analyzeDiff } from '../../analyzers/analyzer';
+import { generateAIResponse, getCommitPrompt } from '../../utils/ai';
+import { interactiveRefinePrompt } from '../../utils/inquirer';
+import ora from 'ora';
+
+let provider = getProvider();
+
+export default async (flags: any = {}) => {
+  try {
+    if (!provider) {
+      throw new Error('No provider set');
+    }
+
+    const runProvider = flags.model ? flags.model : provider;
+
+    console.log('');
+    console.log(chalk.bold.bgBlue(' 🚀 AI-SHIP ') + chalk.bold.blue(' Commit Generator '));
+    console.log(chalk.dim('==================================='));
+    console.log('');
+
+    // 1️⃣ Get staged files
+    const scanSpinner = ora('Scanning staged files...').start();
+    const filesChanged = await getFilesChanged();
+
+    if (!filesChanged.length) {
+      scanSpinner.fail(chalk.yellow('No staged files detected.'));
+      return;
+    }
+
+    // 2️⃣ Expand directories
+    const expandedFiles = expandDirectories(filesChanged);
+
+    // 3️⃣ Extract filenames
+    let filenames = expandedFiles.map((f) => f.file);
+
+    // 4️⃣ Filter noise files
+    filenames = filterNoiseFiles(filenames);
+
+    scanSpinner.succeed(`Found ${filesChanged.length} staged file(s).`);
+
+    console.log(chalk.dim('Files changed:'));
+    filesChanged.forEach((f) => console.log(chalk.green(`  + ${f.file}`)));
+    console.log('');
+
+    // 5️⃣ Analyze diff
+    const analyzeSpinner = ora('Analyzing file changes changes').start();
+
+    const diffs = await getStagedDiff(filenames);
+    const diffSummary = analyzeDiff(diffs);
+    analyzeSpinner.succeed('Analysis complete.\n');
+
+    // 6️⃣ Commit message generation
+    let commitMessage = '';
+    let commitAccepted = false;
+
+    while (!commitAccepted) {
+      const commitSpinner = ora('Generating commit message...').start();
+
+      const prompt = getCommitPrompt(runProvider, diffSummary);
+      commitMessage = await generateAIResponse(runProvider, prompt);
+
+      commitSpinner.succeed('Commit message generated:\\n');
+
+      console.log(chalk.cyan(commitMessage));
+      console.log('');
+
+      // dry-run → exit early
+      if (flags['dry-run']) {
+        console.log(chalk.yellow('Dry run enabled. Commit not executed.\\n'));
+        const unstageSpinner = ora('Unstaging files...').start();
+        await unstageFiles();
+        unstageSpinner.succeed('Files unstaged.');
+        return;
+      }
+
+      // skip prompt if --yes
+      if (flags['yes']) {
+        commitAccepted = true;
+        break;
+      }
+
+      const result = await interactiveRefinePrompt('commit message', commitMessage);
+      if (result.cancel) return;
+
+      commitAccepted = result.accepted;
+      commitMessage = result.value;
+    }
+
+    // 7️⃣ Commit
+    const commitSpinner = ora('Committing changes...').start();
+    await gitCommit(commitMessage);
+    commitSpinner.succeed('Changes successfully committed!\n');
+    return { commitMessage, diffSummary, runProvider };
+  } catch (err) {
+    console.log(err);
+    if ((err as Error).name === 'ExitPromptError') {
+      console.log(chalk.yellow('\nProcess aborted using user prompt.\n'));
+      return;
+    }
+
+    log(chalk.red(`We ran into an error: ${err}`));
+  }
+};

package/src/commands/git/startPR.ts

@@ -0,0 +1,66 @@
+import ora from 'ora';
+import chalk from 'chalk';
+import { pRPrompt } from '../../utils/prompts';
+import { getCurrentBranchName } from '../../utils/git';
+import { createPR } from '../github/github';
+import { log } from '../../utils/helper';
+import { generateAIResponse } from '../../utils/ai';
+
+export const startPR = async ({
+  diffSummary,
+  commitMessage,
+  provider,
+  flags,
+}: {
+  diffSummary: any;
+  commitMessage: string;
+  provider: any;
+  flags: any;
+}) => {
+  try {
+    const spinner = ora('Generating PR...').start();
+
+    const branchName = await getCurrentBranchName();
+
+    const prompt = pRPrompt({
+      commitMessage,
+      branchName,
+      summary: diffSummary,
+    });
+
+    const response = await generateAIResponse(provider, prompt);
+
+    spinner.succeed('PR content generated.\n');
+
+    // 🔥 Parse response
+    const titleMatch = response.match(/TITLE:\s*(.*)/);
+    const descriptionMatch = response.match(/DESCRIPTION:\s*([\s\S]*)/);
+
+    if (!titleMatch || !descriptionMatch) {
+      throw new Error('Failed to parse PR output');
+    }
+
+    const title = titleMatch[1].trim();
+    const body = descriptionMatch[1].trim();
+
+    const createSpinner = ora('Creating PR...').start();
+
+    const targetBranch = flags['target-branch'] || flags['base'] || 'main';
+
+    const prResult = await createPR({
+      title,
+      body,
+      head: branchName,
+      base: targetBranch,
+    });
+
+    createSpinner.succeed(chalk.green('PR created successfully!\n'));
+
+    if (prResult.stdout && prResult.stdout.trim()) {
+      console.log(chalk.blue(`🔗 PR Link: ${prResult.stdout.trim()}\n`));
+    }
+  } catch (err) {
+    console.log(err);
+    log(chalk.red(`PR generation failed: ${err}`));
+  }
+};

package/src/commands/git/startPush.ts

@@ -0,0 +1,18 @@
+import ora from 'ora';
+import { push } from '../../utils/git';
+import { interactivePushPrompt } from '../../utils/inquirer';
+
+export const gitInteractivePush = async () => {
+  const result = await interactivePushPrompt();
+  if (result.accepted) {
+    const pushSpinner = ora('Pushing changes...').start();
+    await push();
+    pushSpinner.succeed('Changes pushed to remote repository.\n');
+  }
+};
+
+export const gitDirectPush = async () => {
+  const pushSpinner = ora('Pushing changes...').start();
+  await push();
+  pushSpinner.succeed('Changes pushed to remote repository.\n');
+};