ai-ship-cli 0.1.0-beta.1

package/src/commands/git/startWorkflow.ts

@@ -0,0 +1,71 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import startCommit from './startCommit';
+import startCheckout from './startCheckout';
+import { gitDirectPush, gitInteractivePush } from './startPush';
+import { log } from '../../utils/helper';
+import { getAllBranches, getCurrentBranchName, gitFetch } from '../../utils/git';
+import { compressBranchSummary } from '../../analyzers/compressBranchSummary';
+import { startPR } from './startPR';
+import { interactivePRPrompt } from '../../utils/inquirer';
+
+export default async (flags: any = {}) => {
+  try {
+    const commitResult = await startCommit(flags);
+
+    // If startCommit returns void/falsy, it means it was aborted, failed, or was a dry-run
+    if (!commitResult) {
+      return;
+    }
+
+    const { diffSummary, commitMessage, runProvider } = commitResult;
+
+    if (flags['new-branch']) {
+      const branchAnalyzeSpinner = ora('Checking branches...').start();
+      await gitFetch();
+      const allBranches = await getAllBranches();
+      const currentBranch = await getCurrentBranchName();
+
+      const branchSummary = compressBranchSummary(diffSummary);
+      branchAnalyzeSpinner.succeed('Analysis complete.\\n');
+
+      await startCheckout({
+        branchSummary,
+        allBranches,
+        currentBranch,
+        commitMessage,
+        provider: runProvider,
+        flags,
+      });
+    }
+
+    if (flags['push']) {
+      await gitDirectPush();
+    } else {
+      await gitInteractivePush();
+    }
+
+    if (flags['pr']) {
+      await startPR({
+        diffSummary,
+        commitMessage,
+        provider: runProvider,
+        flags,
+      });
+    } else {
+      const prPromptResult = await interactivePRPrompt(flags['target-branch'] || 'main');
+      if (prPromptResult.accepted) {
+        flags['target-branch'] = prPromptResult.base;
+        await startPR({
+          diffSummary,
+          commitMessage,
+          provider: runProvider,
+          flags,
+        });
+      }
+    }
+  } catch (err) {
+    console.log(err);
+    log(chalk.red(`Workflow encountered an error: ${err}`));
+  }
+};

package/src/commands/github/github.ts

@@ -0,0 +1,72 @@
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+export const createPR = async ({
+  title,
+  body,
+  base = 'main',
+  head,
+}: {
+  title: string;
+  body: string;
+  base?: string;
+  head: string;
+}): Promise<{ stdout: string; stderr: string }> => {
+  return new Promise((resolve, reject) => {
+    try {
+      // 🔥 Create temp file for PR body
+      const tempFile = path.join(process.cwd(), '.ai-ship-pr.md');
+      fs.writeFileSync(tempFile, body);
+
+      // 🔥 Safe args (NO shell)
+      const args = [
+        'pr',
+        'create',
+        '--title',
+        title,
+        '--body-file',
+        tempFile,
+        '--base',
+        base,
+        '--head',
+        head,
+      ];
+
+      const child = spawn('gh', args); // ✅ no shell
+
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout?.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      child.stderr?.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      child.on('close', (code) => {
+        // 🧹 cleanup temp file
+        try {
+          fs.unlinkSync(tempFile);
+        } catch {}
+
+        if (code === 0) {
+          resolve({ stdout, stderr });
+        } else {
+          const error = new Error(`Command failed: gh pr create\n${stderr}`);
+          (error as any).stdout = stdout;
+          (error as any).stderr = stderr;
+          reject(error);
+        }
+      });
+
+      child.on('error', (err) => {
+        reject(err);
+      });
+    } catch (err) {
+      reject(err);
+    }
+  });
+};

package/src/index.ts

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import minimist from 'minimist';
+import runConfig from './commands/config';
+import runCommit from './commands/commit';
+import chalk from 'chalk';
+
+const startCommandExecution = async () => {
+  const args = minimist(process.argv.slice(2));
+
+  const command = args._[0];
+
+  const subArgs = {
+    ...args,
+    _: args._.slice(1),
+  };
+  console.log('');
+  console.log(chalk.bold.bgBlue(' 🚀 AI-SHIP ') + chalk.bold.blue(' Commit Generator '));
+  console.log(chalk.dim('==================================='));
+  console.log('');
+
+  switch (command) {
+    case 'commit':
+      const { _, ...flags } = subArgs;
+      await runCommit(_, flags);
+      break;
+
+    case 'config':
+      await runConfig(subArgs);
+      break;
+
+    // case 'pr':
+    //   await run
+    default:
+      console.log('Unknown command');
+  }
+  console.log('');
+};
+
+startCommandExecution();

package/src/utils/ai.ts

@@ -0,0 +1,30 @@
+import { generateWithGemma } from '../ai/ollama';
+import { generateWithGemini } from '../ai/gemini';
+import {
+  buildBranchPrompt,
+  buildBranchPromptGemma,
+  buildCommitPrompt,
+  buildCommitPromptGemma,
+} from './prompts';
+
+export const generateAIResponse = async (provider: string, prompt: string) => {
+  return provider === 'local' ? await generateWithGemma(prompt) : await generateWithGemini(prompt);
+};
+
+export const getCommitPrompt = (provider: string, diffSummary: any[]) => {
+  return provider === 'local'
+    ? buildCommitPromptGemma(diffSummary)
+    : buildCommitPrompt(diffSummary);
+};
+
+export const getBranchPrompt = (
+  provider: string,
+  branchSummary: any[],
+  allBranches: string[],
+  currentBranch: string,
+  commitMessage: string,
+) => {
+  return provider === 'local'
+    ? buildBranchPromptGemma(branchSummary, allBranches, currentBranch, commitMessage)
+    : buildBranchPrompt(branchSummary, allBranches, currentBranch, commitMessage);
+};

package/src/utils/asyncExecuter.ts

@@ -0,0 +1,39 @@
+import { spawn } from 'child_process';
+
+export default async function asyncExecuter(
+  command: string,
+): Promise<{ stdout: string; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, { shell: true });
+
+    let stdout = '';
+    let stderr = '';
+
+    if (child.stdout) {
+      child.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+    }
+
+    if (child.stderr) {
+      child.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+    }
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve({ stdout, stderr });
+      } else {
+        const error = new Error(`Command failed: ${command}\n${stderr}`);
+        (error as any).stdout = stdout;
+        (error as any).stderr = stderr;
+        reject(error);
+      }
+    });
+
+    child.on('error', (err) => {
+      reject(err);
+    });
+  });
+}

package/src/utils/files.ts

@@ -0,0 +1,30 @@
+import fs from 'fs';
+import path from 'path';
+
+type FileChange = {
+  status: string;
+  file: string;
+};
+
+export const expandDirectories = (files: FileChange[]): FileChange[] => {
+  const expanded: FileChange[] = [];
+
+  files.forEach(({ status, file }) => {
+    if (fs.existsSync(file) && fs.lstatSync(file).isDirectory()) {
+      const subFiles = fs.readdirSync(file);
+
+      subFiles.forEach((subFile) => {
+        const fullPath = path.join(file, subFile);
+
+        expanded.push({
+          status,
+          file: fullPath,
+        });
+      });
+    } else {
+      expanded.push({ status, file });
+    }
+  });
+
+  return expanded;
+};

package/src/utils/git.ts

@@ -0,0 +1,108 @@
+import path from 'path';
+import asyncExecuter from './asyncExecuter';
+
+export const getGitRoot = async () => {
+  const { stdout } = await asyncExecuter('git rev-parse --show-toplevel');
+  return stdout.trim();
+};
+
+export const getFilesChanged = async () => {
+  const { stdout: filesChanged } = await asyncExecuter('git diff --cached --name-status');
+
+  if (!filesChanged.trim()) return [];
+
+  const root = await getGitRoot();
+
+  return filesChanged
+    .trim()
+    .split('\n')
+    .map((line) => {
+      const parts = line.split('\t');
+      const status = parts[0]?.trim();
+
+      let filePath: string | undefined;
+
+      if (status?.startsWith('R')) {
+        // Rename → take NEW path
+        filePath = parts[2];
+      } else {
+        filePath = parts[1];
+      }
+
+      if (!filePath) {
+        throw new Error(`Invalid git diff line: ${line}`);
+      }
+
+      return {
+        status,
+        file: path.resolve(root, filePath.trim().replace(/^[.\\/]+/, '')),
+      };
+    });
+};
+
+export const stageAll = async () => {
+  await asyncExecuter('git add -A');
+};
+
+export const stageFiles = async (files: string[]) => {
+  if (!files || files.length === 0) return;
+
+  const filesString = files.map((f) => `"${f}"`).join(' ');
+  await asyncExecuter(`git add ${filesString}`);
+};
+
+export const getStagedDiff = async (files: string[]) => {
+  const filesString = files.map((f) => `"${f}"`).join(' ');
+  const { stdout } = await asyncExecuter(`git diff --cached -- ${filesString}`);
+  return stdout;
+};
+
+export const gitFetch = async () => {
+  return await asyncExecuter('git fetch --all');
+};
+
+export const getAllBranches = async () => {
+  const { stdout: raw } = await asyncExecuter('git branch -a');
+
+  const branches = raw
+    .split('\\n')
+    .map((b) => b.replace('*', '').trim())
+    .map((b) => b.replace('remotes/origin/', ''))
+    .filter(Boolean);
+
+  return [...new Set(branches)];
+};
+
+export const getCurrentBranchName = async () => {
+  return (await asyncExecuter('git branch --show-current')).stdout.trim();
+};
+
+export const gitCommit = async (message: string) => {
+  // Use child_process safely by escaping quotes properly, or just use asyncExecuter
+  const escapedMessage = message.replace(/(["'$`\\])/g, '\\\\$1');
+  await asyncExecuter(`git commit -m "${escapedMessage}"`);
+};
+
+export const gitRenameBranch = async (branchName: string) => {
+  await asyncExecuter(`git branch -m "${branchName}"`);
+};
+
+export const gitCheckoutNewBranch = async (branchName: string) => {
+  await asyncExecuter(`git checkout -b ${branchName}`);
+};
+
+export const unstageFiles = async () => {
+  await asyncExecuter(`git reset`);
+};
+
+export const push = async () => {
+  try {
+    await asyncExecuter(`git push`);
+  } catch {
+    const { stdout } = await asyncExecuter(`git rev-parse --abbrev-ref HEAD`);
+
+    const branchName = stdout.trim();
+
+    await asyncExecuter(`git push --set-upstream origin ${branchName}`);
+  }
+};

package/src/utils/github.ts

@@ -0,0 +1,19 @@
+export const createGithubPR = async ({
+  title,
+  body,
+  base = 'main',
+  head,
+}: {
+  title: string;
+  body: string;
+  base?: string;
+  head: string;
+}) => {
+  try {
+    await createGithubPR({ title, body, base, head });
+  } catch (error) {
+    console.error('Failed to create GitHub PR.');
+
+    throw error;
+  }
+};

package/src/utils/helper.ts

@@ -0,0 +1,145 @@
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+import chalk from 'chalk';
+type AIShipConfig = {
+  provider: 'local' | 'cloud';
+  model: string;
+  localEndpoint?: string;
+  geminiApiKey?: string;
+};
+
+const ALLOWED_KEYS = ['provider', 'model', 'localEndpoint', 'geminiApiKey'];
+
+export const log = (data: any) => console.log(data);
+
+// config dir for storing api key
+export const CONFIG_DIR = path.join(os.homedir(), '.ai-ship');
+// config file for storing api key
+export const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+export const deleteConfigKey = (key: string): boolean => {
+  if (!fs.existsSync(CONFIG_FILE)) return false;
+  try {
+    const raw = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    const config = raw ? JSON.parse(raw) : {};
+    if (config[key]) {
+      delete config[key];
+      fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+};
+
+export const getCurrentConfig = (key: string = 'all') => {
+  if (!fs.existsSync(CONFIG_FILE)) return null;
+
+  const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+
+  if (key === 'all') return config;
+
+  return config[key];
+};
+export const verboseConfig = (config: any) => {
+  const { provider, model, localEndpoint, geminiApiKey } = config;
+
+  const maskedKey = geminiApiKey
+    ? geminiApiKey.slice(0, 4) + '...' + geminiApiKey.slice(-4)
+    : 'not configured';
+
+  console.log(chalk.bold('\nAI-Ship Configuration\n'));
+
+  console.log(chalk.yellow('Provider'));
+  console.log('  Current:', provider || 'not set');
+  console.log('  Description: Determines where AI runs (local via Ollama or cloud API)\n');
+
+  console.log(chalk.yellow('Model'));
+  console.log('  Current:', model || 'not set');
+  console.log('  Description: AI model used for commit and branch generation\n');
+
+  console.log(chalk.yellow('Local Model Settings'));
+  console.log('  Endpoint:', localEndpoint || 'not configured');
+  console.log('  Description: URL of the local model server (e.g. http://127.0.0.1:11434)\n');
+
+  console.log(chalk.yellow('Cloud Model Settings'));
+  console.log('  Gemini API Key:', maskedKey);
+  console.log('  Description: API key used when provider is set to cloud\n');
+};
+
+export const jsonConfig = (config: any) => {
+  const safeConfig = {
+    provider: config.provider || null,
+    model: config.model || null,
+    localEndpoint: config.localEndpoint || null,
+    geminiApiKey: config.geminiApiKey
+      ? config.geminiApiKey.slice(0, 4) + '...' + config.geminiApiKey.slice(-4)
+      : null,
+  };
+
+  console.log(JSON.stringify(safeConfig, null, 2));
+};
+
+const validateValue = (key: string, value: string) => {
+  switch (key) {
+    case 'provider':
+      if (!['local', 'cloud'].includes(value)) {
+        throw new Error("provider must be 'local' or 'cloud'");
+      }
+      break;
+
+    case 'model':
+      if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new Error('model must be a non-empty string');
+      }
+      break;
+
+    case 'localEndpoint':
+      try {
+        new URL(value);
+      } catch {
+        throw new Error('localEndpoint must be a valid URL');
+      }
+      break;
+
+    case 'geminiApiKey':
+      if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new Error('geminiApiKey must be a valid string');
+      }
+      break;
+  }
+};
+
+export const saveValueToConfig = (key: string, value: string) => {
+  try {
+    if (!ALLOWED_KEYS.includes(key as any)) {
+      throw new Error(`Invalid config key: ${key}. Allowed keys: ${ALLOWED_KEYS.join(', ')}`);
+    }
+
+    validateValue(key, value);
+
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+
+    let config: Record<string, any> = {};
+
+    if (fs.existsSync(CONFIG_FILE)) {
+      const raw = fs.readFileSync(CONFIG_FILE, 'utf-8');
+      config = raw ? JSON.parse(raw) : {};
+    }
+
+    config[key] = value;
+
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+
+    console.log(chalk.green(`✔ Config updated: ${chalk.bold.green(key)}`));
+  } catch (err: any) {
+    console.error(chalk.red(`❌ Failed to save config: ${chalk.bold.red(err.message)}`));
+  }
+};
+
+export const getProvider = () => {
+  return getCurrentConfig('provider');
+};

package/src/utils/inputs.ts

@@ -0,0 +1,15 @@
+import readline from 'readline';
+
+export const askApiKey = (): Promise<string> => {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question('Enter your Gemini API key: ', (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+};

package/src/utils/inquirer.ts

@@ -0,0 +1,99 @@
+import inquirer from 'inquirer';
+// @ts-ignore
+import { Input } from 'enquirer';
+import chalk from 'chalk';
+
+export type AIGenerationResult = {
+  accepted: boolean;
+  value: string;
+  cancel: boolean;
+};
+
+export type pushPromptResult = {
+  accepted: boolean;
+  cancel: boolean;
+};
+
+export const interactiveRefinePrompt = async (
+  itemType: string,
+  initialValue: string,
+): Promise<AIGenerationResult> => {
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: `What would you like to do with this ${itemType}?`,
+      choices: ['Continue', 'Edit', 'Retry', 'Cancel'],
+    },
+  ]);
+
+  if (action === 'Continue') {
+    return { accepted: true, value: initialValue, cancel: false };
+  }
+
+  if (action === 'Edit') {
+    const promptInput = new Input({
+      message: `Edit your ${itemType}:`,
+      initial: initialValue,
+    });
+    const editedValue = (await promptInput.run()) as string;
+    return { accepted: true, value: editedValue, cancel: false };
+  }
+
+  if (action === 'Retry') {
+    console.log(chalk.yellow(`Retrying ${itemType}...\\n`));
+    return { accepted: false, value: initialValue, cancel: false };
+  }
+
+  // Cancel
+  console.log(
+    chalk.yellow(`${itemType.charAt(0).toUpperCase() + itemType.slice(1)} cancelled.\\n`),
+  );
+  return { accepted: false, value: initialValue, cancel: true };
+};
+
+export const interactivePushPrompt = async (): Promise<pushPromptResult> => {
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: `Do you want to push your committed changes to the remote repository?`,
+      choices: ['Yes', 'No'],
+    },
+  ]);
+
+  if (action === 'Yes') {
+    return { accepted: true, cancel: false };
+  }
+
+  console.log(chalk.yellow(`Push cancelled\n`));
+  return { accepted: false, cancel: true };
+};
+
+export const interactivePRPrompt = async (
+  defaultBase: string = 'main',
+): Promise<{ accepted: boolean; cancel: boolean; base: string }> => {
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: `Do you want to create a pull request?`,
+      choices: ['Yes', 'No'],
+    },
+  ]);
+
+  if (action === 'Yes') {
+    const { base } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'base',
+        message: `Which branch do you want to target?`,
+        default: defaultBase,
+      },
+    ]);
+    return { accepted: true, cancel: false, base };
+  }
+
+  console.log(chalk.yellow(`PR creation cancelled\n`));
+  return { accepted: false, cancel: true, base: defaultBase };
+};