git-yapyap-cli 1.0.0

package/README.md

@@ -0,0 +1,103 @@
+# 🗣️ Git YapYap
+
+> AI-powered GitHub activity summarizer — see what you shipped, instantly.
+
+Git YapYap fetches your GitHub commits for any date, groups them by repository, and generates incredibly concise AI-powered summaries of your daily work. Perfect for standups, daily logs, tracking what you actually accomplished, or just reflecting on your productivity.
+
+## ✨ Features
+- **Fetch Past Commits**: Search any specific date (yesterday, today, or months ago).
+- **Multi-Provider AI**: Use OpenAI, Google Gemini, Anthropic Claude, Groq, or Local LLMs to generate your summaries. The power is in your hands.
+- **Private Repository Support**: With the right token scope, seamlessly summarize your private work without any fuss!
+- **Fast & Interactive Setup**: 30-second interactive CLI configuration wizard.
+- **Zero Configuration Daily Use**: Just type `yap yap` anywhere in your terminal.
+
+---
+
+## 🚀 Installation & Distribution
+
+Git YapYap is designed to be installed globally on your machine using Node.js.
+
+### Option A: Install direct from source (Local)
+1. Clone this repository or download the source code wrapper.
+2. Inside the project directory, install the dependencies and link it globally:
+   ```bash
+   npm install -g .
+   ```
+
+### Option B: Publishing to NPM (For worldwide release)
+If you decide to release this to the world, log in to your NPM account and publish!
+```bash
+npm login
+npm publish
+```
+Then, anyone can install your tool directly via NPM with:
+```bash
+npm install -g git-yap
+```
+
+---
+
+## ⚙️ How to Setup (One-Time)
+
+Once you install `git-yap`, you only need to run the setup wizard **once**.
+
+```bash
+yap setup
+```
+
+You will need two things to complete setup:
+### 1. GitHub Personal Access Token (PAT)
+Git YapYap needs a GitHub token to securely fetch your commits.
+1. Go to your [GitHub Personal Access Tokens settings area](https://github.com/settings/tokens).
+2. Click **Generate new token (classic)**.
+3. In the Scopes section, **check the `repo` box**. *(This is required if you want it to summarize private repositories!)*
+4. Keep the token safe and paste it into the CLI wizard when asked.
+
+### 2. AI Platform Setup (API Key)
+Pick your favorite LLM provider and grab a free API key:
+- **Groq**: Free and blazingly fast `llama3` models. Get an API key at [console.groq.com](https://console.groq.com/keys).
+- **Google Gemini**: Highly-capable `gemini-2.0-flash`. Get an API key at [aistudio.google.com](https://aistudio.google.com/app/apikey).
+- **OpenAI**: The standard `gpt-4o-mini`. Get an API key at [platform.openai.com](https://platform.openai.com/api-keys).
+- **Anthropic / Local**: Supported too!
+
+---
+
+## 📖 Usage
+
+Using Git YapYap is as simple as it gets. You don't need to specify formats, just tell it when to yap.
+
+```bash
+# Today's activity
+yap yap
+
+# Yesterday's activity
+yap yesterday
+
+# A specific date (DDMMYYYY, DD-MM-YYYY, or DD/MM/YYYY)
+yap 16032026
+yap 16-03-2026
+yap 16/03/2026
+```
+
+### Example Summary Output:
+
+```text
+📅 Activity for Sunday, March 14, 2026
+─────────────────────────────────────────────
+✔ Fetched GitHub activity
+✔ Generated summaries
+
+📦 abnv-o/Hypnohands (1 commit)
+   The Hypnohands repository received an update to include a meta pixel.
+   This addition enhances tracking capabilities for the project.
+
+─────────────────────────────────────────────
+✨ 1 repository · 1 commit
+```
+
+---
+
+## 🏗️ Version 1.0.0
+This tool is robust, clean, and tested. Future versions may add local summary caching, output to markdown, and extra email filters.
+
+**License**: MIT

package/bin/yap.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { getConfig, isConfigured } from "../src/config.js";
+import { runSetup } from "../src/setup.js";
+import { parseDate } from "../src/dateParser.js";
+import { fetchCommits } from "../src/github.js";
+import { summarizeCommits } from "../src/summarizer.js";
+
+const program = new Command();
+
+program
+  .name("yap")
+  .description("🗣️  Git YapYap — AI-powered GitHub activity summarizer")
+  .version("1.0.0");
+
+// ─── Setup Command ─────────────────────────────────────────
+
+program
+  .command("setup")
+  .description("Configure GitHub and AI credentials")
+  .action(async () => {
+    await runSetup();
+  });
+
+// ─── Default Command (fetch & summarize) ────────────────────
+
+program
+  .argument(
+    "[date]",
+    "Date to fetch commits for (yap, yesterday, DDMMYYYY, DD-MM-YYYY, DD/MM/YYYY)",
+  )
+  .action(async (dateArg) => {
+    // Check if configured
+    if (!isConfigured()) {
+      console.log(chalk.yellow("\n⚠️  Git YapYap is not configured yet.\n"));
+      console.log(
+        chalk.dim("Run ") +
+          chalk.cyan("yap setup") +
+          chalk.dim(" to get started.\n"),
+      );
+      process.exit(1);
+    }
+
+    const config = getConfig();
+
+    // Parse the date
+    let dateRange;
+    try {
+      dateRange = parseDate(dateArg);
+    } catch (error) {
+      console.log(chalk.red(`\n❌ ${error.message}\n`));
+      process.exit(1);
+    }
+
+    // Header
+    console.log(chalk.bold.cyan(`\n📅 Activity for ${dateRange.displayDate}`));
+    console.log(chalk.dim("─".repeat(45)));
+
+    // Fetch commits
+    const fetchSpinner = ora("Fetching GitHub activity...").start();
+    let commitsByRepo;
+    try {
+      commitsByRepo = await fetchCommits(
+        config.githubToken,
+        dateRange.since,
+        dateRange.until,
+      );
+      fetchSpinner.succeed(chalk.dim("Fetched GitHub activity"));
+    } catch (error) {
+      fetchSpinner.fail(chalk.red("Failed to fetch GitHub activity"));
+      console.log(chalk.red(`\n${error.message}\n`));
+      process.exit(1);
+    }
+
+    // Check if any commits found
+    const repoNames = Object.keys(commitsByRepo);
+    if (repoNames.length === 0) {
+      console.log(chalk.yellow("\n😴 No commits found for this date.\n"));
+      console.log(
+        chalk.dim(
+          "Either you took a day off (nice!) or try a different date.\n",
+        ),
+      );
+      process.exit(0);
+    }
+
+    // Count total commits
+    const totalCommits = repoNames.reduce(
+      (sum, repo) => sum + commitsByRepo[repo].length,
+      0,
+    );
+
+    // Summarize each repo
+    const summarySpinner = ora("Generating AI summaries...").start();
+    const summaries = {};
+
+    for (const repo of repoNames) {
+      summarySpinner.text = `Summarizing ${chalk.cyan(repo)}...`;
+      summaries[repo] = await summarizeCommits(
+        config,
+        repo,
+        commitsByRepo[repo],
+      );
+    }
+    summarySpinner.succeed(chalk.dim("Generated summaries"));
+
+    // Output
+    console.log("");
+    for (const repo of repoNames) {
+      const commitCount = commitsByRepo[repo].length;
+      const commitWord = commitCount === 1 ? "commit" : "commits";
+      console.log(
+        chalk.bold(`📦 ${repo}`) + chalk.dim(` (${commitCount} ${commitWord})`),
+      );
+
+      // Print raw commit messages
+      for (const commit of commitsByRepo[repo]) {
+        console.log(chalk.dim(`   • ${commit.message}`));
+      }
+      console.log(""); // blank line between commits and summary
+
+      // Print AI summary
+      const summaryLines = summaries[repo].split("\n").filter((l) => l.trim());
+      for (const line of summaryLines) {
+        console.log(chalk.white(`   ${line.trim()}`));
+      }
+      console.log("");
+    }
+
+    // Footer
+    console.log(chalk.dim("─".repeat(45)));
+    const repoWord = repoNames.length === 1 ? "repository" : "repositories";
+    const commitWord = totalCommits === 1 ? "commit" : "commits";
+    console.log(
+      chalk.green(
+        `✨ ${repoNames.length} ${repoWord} · ${totalCommits} ${commitWord}\n`,
+      ),
+    );
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "git-yapyap-cli",
+  "version": "1.0.0",
+  "description": "Git YapYap — AI-powered GitHub activity summarizer. See what you shipped today.",
+  "type": "module",
+  "files": [
+    "bin",
+    "src"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "bin": {
+    "yap": "bin/yap.js"
+  },
+  "scripts": {
+    "start": "node bin/yap.js"
+  },
+  "keywords": [
+    "github",
+    "commits",
+    "ai",
+    "summary",
+    "cli",
+    "productivity"
+  ],
+  "author": "Abhinav",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "conf": "^13.0.1",
+    "inquirer": "^9.3.7",
+    "octokit": "^4.1.2",
+    "openai": "^4.77.0",
+    "ora": "^8.1.1"
+  }
+}

package/src/config.js

@@ -0,0 +1,55 @@
+import Conf from "conf";
+
+const config = new Conf({
+  projectName: "git-yap",
+  schema: {
+    githubToken: {
+      type: "string",
+      default: "",
+    },
+    aiProvider: {
+      type: "string",
+      enum: ["openai", "gemini", "claude", "groq", "local"],
+      default: "openai",
+    },
+    aiApiKey: {
+      type: "string",
+      default: "",
+    },
+    aiModel: {
+      type: "string",
+      default: "",
+    },
+    aiBaseUrl: {
+      type: "string",
+      default: "",
+    },
+  },
+});
+
+export function getConfig() {
+  return {
+    githubToken: config.get("githubToken"),
+    aiProvider: config.get("aiProvider"),
+    aiApiKey: config.get("aiApiKey"),
+    aiModel: config.get("aiModel"),
+    aiBaseUrl: config.get("aiBaseUrl"),
+  };
+}
+
+export function setConfig(key, value) {
+  config.set(key, value);
+}
+
+export function isConfigured() {
+  const cfg = getConfig();
+  return !!(
+    cfg.githubToken &&
+    cfg.aiProvider &&
+    (cfg.aiApiKey || cfg.aiProvider === "local")
+  );
+}
+
+export function clearConfig() {
+  config.clear();
+}

package/src/dateParser.js

@@ -0,0 +1,64 @@
+/**
+ * Parse a user-provided date string into { since, until } ISO timestamps
+ * covering the full day in the local timezone.
+ *
+ * Supported formats:
+ *   "yap" / undefined  → today
+ *   "yesterday"        → yesterday
+ *   "16032026"         → DDMMYYYY
+ *   "16-03-2026"       → DD-MM-YYYY
+ *   "16/03/2026"       → DD/MM/YYYY
+ */
+export function parseDate(input) {
+  let targetDate;
+
+  if (!input || input.toLowerCase() === "yap") {
+    // Today
+    targetDate = new Date();
+  } else if (input.toLowerCase() === "yesterday") {
+    targetDate = new Date();
+    targetDate.setDate(targetDate.getDate() - 1);
+  } else if (/^\d{8}$/.test(input)) {
+    // DDMMYYYY
+    const day = parseInt(input.slice(0, 2), 10);
+    const month = parseInt(input.slice(2, 4), 10) - 1;
+    const year = parseInt(input.slice(4, 8), 10);
+    targetDate = new Date(year, month, day);
+  } else if (/^\d{1,2}[-/]\d{1,2}[-/]\d{4}$/.test(input)) {
+    // DD-MM-YYYY or DD/MM/YYYY
+    const parts = input.split(/[-/]/);
+    const day = parseInt(parts[0], 10);
+    const month = parseInt(parts[1], 10) - 1;
+    const year = parseInt(parts[2], 10);
+    targetDate = new Date(year, month, day);
+  } else {
+    throw new Error(
+      `Invalid date format: "${input}"\n` +
+        `Supported: yap, yesterday, DDMMYYYY, DD-MM-YYYY, DD/MM/YYYY`,
+    );
+  }
+
+  // Validate the parsed date
+  if (isNaN(targetDate.getTime())) {
+    throw new Error(`Could not parse date: "${input}"`);
+  }
+
+  // Start of day (local timezone)
+  const since = new Date(targetDate);
+  since.setHours(0, 0, 0, 0);
+
+  // End of day (local timezone)
+  const until = new Date(targetDate);
+  until.setHours(23, 59, 59, 999);
+
+  return {
+    since: since.toISOString(),
+    until: until.toISOString(),
+    displayDate: targetDate.toLocaleDateString("en-US", {
+      weekday: "long",
+      year: "numeric",
+      month: "long",
+      day: "numeric",
+    }),
+  };
+}

package/src/github.js

@@ -0,0 +1,80 @@
+import { Octokit } from "octokit";
+
+/**
+ * Fetch all commits by the authenticated user for a given date range,
+ * grouped by repository.
+ *
+ * Uses the GitHub Events API (GET /users/{username}/events) to fetch
+ * PushEvent entries, then filters by date and extracts commits.
+ *
+ * @param {string} token - GitHub Personal Access Token
+ * @param {string} since - ISO timestamp (start of day)
+ * @param {string} until - ISO timestamp (end of day)
+ * @returns {Promise<Object>} - { "owner/repo": [{ sha, message, timestamp, url }] }
+ */
+export async function fetchCommits(token, since, until) {
+  const octokit = new Octokit({ auth: token });
+
+  // Get authenticated user's login
+  const { data: user } = await octokit.rest.users.getAuthenticated();
+  const username = user.login;
+
+  const commitsByRepo = {};
+  let page = 1;
+  const perPage = 100;
+  let keepGoing = true;
+
+  // The since/until variables are already full ISO strings like "2026-03-13T18:30:00.000Z"
+  // Format them for the search query, replacing the ".000Z" with "Z" if necessary, though it works fine.
+  const query = `author:${username} author-date:${since}..${until}`;
+
+  while (keepGoing && page <= 5) {
+    // max 500 commits per day is plenty
+    const { data } = await octokit.rest.search.commits({
+      q: query,
+      per_page: perPage,
+      page,
+    });
+
+    if (!data.items || data.items.length === 0) {
+      break;
+    }
+
+    for (const item of data.items) {
+      const repoName = item.repository.full_name;
+      if (!commitsByRepo[repoName]) {
+        commitsByRepo[repoName] = [];
+      }
+
+      // Deduplicate by SHA just in case
+      const shortSha = item.sha.substring(0, 7);
+      const alreadyAdded = commitsByRepo[repoName].some(
+        (c) => c.sha === shortSha,
+      );
+
+      if (!alreadyAdded) {
+        commitsByRepo[repoName].push({
+          sha: shortSha,
+          message: item.commit.message.split("\n")[0], // First line only
+          timestamp: item.commit.author.date,
+          url: item.html_url,
+        });
+      }
+    }
+
+    if (data.items.length < perPage) {
+      keepGoing = false;
+    } else {
+      page++;
+    }
+  }
+
+  // Remove empty repos (though search API shouldn't yield empty bins)
+  for (const repo of Object.keys(commitsByRepo)) {
+    if (commitsByRepo[repo].length === 0) {
+      delete commitsByRepo[repo];
+    }
+  }
+
+  return commitsByRepo;
+}

package/src/setup.js

@@ -0,0 +1,125 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import ora from "ora";
+import { Octokit } from "octokit";
+import { setConfig } from "./config.js";
+
+const PROVIDER_DEFAULTS = {
+  openai: { model: "gpt-4o-mini", baseUrl: "" },
+  gemini: { model: "gemini-2.0-flash", baseUrl: "" },
+  claude: { model: "claude-3-5-haiku-20241022", baseUrl: "" },
+  groq: {
+    model: "llama-3.3-70b-versatile",
+    baseUrl: "https://api.groq.com/openai/v1",
+  },
+  local: { model: "llama3", baseUrl: "http://localhost:11434/v1" },
+};
+
+export async function runSetup() {
+  console.log(chalk.bold.cyan("\n🔧 Git YapYap Setup\n"));
+  console.log(chalk.dim("Configure your GitHub and AI credentials.\n"));
+
+  // Step 1: GitHub Token
+  const { githubToken } = await inquirer.prompt([
+    {
+      type: "password",
+      name: "githubToken",
+      message: "GitHub Personal Access Token:",
+      mask: "*",
+      validate: (input) => input.length > 0 || "Token is required",
+    },
+  ]);
+
+  // Validate GitHub token
+  const spinner = ora("Validating GitHub token...").start();
+  try {
+    const octokit = new Octokit({ auth: githubToken });
+    const { data } = await octokit.rest.users.getAuthenticated();
+    spinner.succeed(chalk.green(`Authenticated as ${chalk.bold(data.login)}`));
+  } catch (error) {
+    spinner.fail(
+      chalk.red("Invalid GitHub token. Please check and try again."),
+    );
+    return;
+  }
+
+  // Step 2: AI Provider
+  const { aiProvider } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "aiProvider",
+      message: "Choose your AI provider:",
+      choices: [
+        { name: "OpenAI", value: "openai" },
+        { name: "Google Gemini", value: "gemini" },
+        { name: "Anthropic Claude", value: "claude" },
+        { name: "Groq", value: "groq" },
+        { name: "Local / Custom (Ollama, LM Studio, etc.)", value: "local" },
+      ],
+    },
+  ]);
+
+  // Step 3: API Key
+  let aiApiKey = "";
+  if (aiProvider !== "local") {
+    const response = await inquirer.prompt([
+      {
+        type: "password",
+        name: "aiApiKey",
+        message: `${aiProvider.charAt(0).toUpperCase() + aiProvider.slice(1)} API Key:`,
+        mask: "*",
+        validate: (input) => input.length > 0 || "API key is required",
+      },
+    ]);
+    aiApiKey = response.aiApiKey;
+  } else {
+    const response = await inquirer.prompt([
+      {
+        type: "password",
+        name: "aiApiKey",
+        message: "API Key (leave empty if not needed):",
+        mask: "*",
+      },
+    ]);
+    aiApiKey = response.aiApiKey || "";
+  }
+
+  // Step 4: Model
+  const defaults = PROVIDER_DEFAULTS[aiProvider];
+  const { aiModel } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "aiModel",
+      message: "Model name:",
+      default: defaults.model,
+    },
+  ]);
+
+  // Step 5: Base URL (for Groq / Local)
+  let aiBaseUrl = defaults.baseUrl;
+  if (aiProvider === "groq" || aiProvider === "local") {
+    const response = await inquirer.prompt([
+      {
+        type: "input",
+        name: "aiBaseUrl",
+        message: "API Base URL:",
+        default: defaults.baseUrl,
+      },
+    ]);
+    aiBaseUrl = response.aiBaseUrl;
+  }
+
+  // Save everything
+  setConfig("githubToken", githubToken);
+  setConfig("aiProvider", aiProvider);
+  setConfig("aiApiKey", aiApiKey);
+  setConfig("aiModel", aiModel);
+  setConfig("aiBaseUrl", aiBaseUrl);
+
+  console.log(chalk.bold.green("\n✅ Setup complete! You're ready to go.\n"));
+  console.log(
+    chalk.dim("Try running: ") +
+      chalk.cyan("yap yap") +
+      chalk.dim(" to see today's activity.\n"),
+  );
+}

package/src/summarizer.js

@@ -0,0 +1,122 @@
+import OpenAI from "openai";
+
+/**
+ * Generate a 2-line summary for a repository's commits using the configured AI provider.
+ *
+ * Supports: openai, gemini, claude, groq, local (OpenAI-compatible)
+ *
+ * @param {Object} config - { aiProvider, aiApiKey, aiModel, aiBaseUrl }
+ * @param {string} repoName - Repository name (e.g., "owner/repo")
+ * @param {Array} commits - Array of { sha, message, timestamp }
+ * @returns {Promise<string>} - 2-line summary
+ */
+export async function summarizeCommits(config, repoName, commits) {
+  const commitMessages = commits.map((c) => `- ${c.message}`).join("\n");
+
+  const prompt = `You are a concise technical writer. Summarize the following git commits for the repository "${repoName}" in exactly 2 short lines. Focus on what was accomplished overall, not individual commits. Be specific and informative.
+
+Commits:
+${commitMessages}
+
+Respond with exactly 2 lines, nothing else.`;
+
+  const { aiProvider, aiApiKey, aiModel, aiBaseUrl } = config;
+
+  try {
+    switch (aiProvider) {
+      case "openai":
+        return await callOpenAI(aiApiKey, aiModel, prompt);
+      case "groq":
+      case "local":
+        return await callOpenAICompatible(aiApiKey, aiModel, aiBaseUrl, prompt);
+      case "gemini":
+        return await callGemini(aiApiKey, aiModel, prompt);
+      case "claude":
+        return await callClaude(aiApiKey, aiModel, prompt);
+      default:
+        throw new Error(`Unknown AI provider: ${aiProvider}`);
+    }
+  } catch (error) {
+    return `⚠️  Could not generate summary: ${error.message}`;
+  }
+}
+
+// ─── OpenAI ──────────────────────────────────────────────────
+
+async function callOpenAI(apiKey, model, prompt) {
+  const client = new OpenAI({ apiKey });
+  const response = await client.chat.completions.create({
+    model: model || "gpt-4o-mini",
+    messages: [{ role: "user", content: prompt }],
+    max_tokens: 150,
+    temperature: 0.3,
+  });
+  return response.choices[0].message.content.trim();
+}
+
+// ─── OpenAI-Compatible (Groq, Local/Ollama, LM Studio) ──────
+
+async function callOpenAICompatible(apiKey, model, baseUrl, prompt) {
+  const client = new OpenAI({
+    apiKey: apiKey || "not-needed",
+    baseURL: baseUrl,
+  });
+  const response = await client.chat.completions.create({
+    model: model || "llama3",
+    messages: [{ role: "user", content: prompt }],
+    max_tokens: 150,
+    temperature: 0.3,
+  });
+  return response.choices[0].message.content.trim();
+}
+
+// ─── Google Gemini (direct REST) ─────────────────────────────
+
+async function callGemini(apiKey, model, prompt) {
+  const url = `https://generativelanguage.googleapis.com/v1beta/models/${model || "gemini-2.0-flash"}:generateContent?key=${apiKey}`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      contents: [{ parts: [{ text: prompt }] }],
+      generationConfig: {
+        maxOutputTokens: 150,
+        temperature: 0.3,
+      },
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Gemini API error: ${response.status} ${error}`);
+  }
+
+  const data = await response.json();
+  return data.candidates[0].content.parts[0].text.trim();
+}
+
+// ─── Anthropic Claude (direct REST) ──────────────────────────
+
+async function callClaude(apiKey, model, prompt) {
+  const response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+    },
+    body: JSON.stringify({
+      model: model || "claude-3-5-haiku-20241022",
+      max_tokens: 150,
+      messages: [{ role: "user", content: prompt }],
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Claude API error: ${response.status} ${error}`);
+  }
+
+  const data = await response.json();
+  return data.content[0].text.trim();
+}