piqnote 0.1.0

package/src/cli.ts

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { loadConfig, getDefaultConfig } from "./config/loader";
+import { PiqnoteConfig } from "./config/types";
+import { analyzeDiff } from "./analyzer/diffAnalyzer";
+import { scoreCommit } from "./analyzer/scorer";
+import { formatCommit } from "./formatter/commitFormatter";
+import { getProvider, generateWithProvider } from "./ai/factory";
+import {
+  getStagedDiff,
+  isGitRepo,
+  hasStagedChanges,
+  getStagedFiles,
+  stageAll,
+  commitMessage,
+  getBranches,
+  getCurrentBranch,
+  checkoutBranch,
+  createBranch,
+} from "./git/gitClient";
+
+interface CliOptions {
+  interactive: boolean;
+  score: boolean;
+  offline: boolean;
+  auto: boolean;
+  dryRun: boolean;
+}
+
+type ActionChoice =
+  | "accept-commit"
+  | "accept-stage"
+  | "edit-subject"
+  | "edit-full"
+  | "regenerate"
+  | "skip";
+
+function ensureBullets(responseBullets: string[] | undefined, stagedFiles: string[]): string[] {
+  if (responseBullets && responseBullets.length) return responseBullets;
+  return stagedFiles.slice(0, 5).map((file) => file);
+}
+
+async function promptAction(): Promise<ActionChoice> {
+  const { action } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "action",
+      message: "What do you want to do?",
+      choices: [
+        { name: "Accept & commit", value: "accept-commit" },
+        { name: "Accept & stage only", value: "accept-stage" },
+        { name: "Edit subject", value: "edit-subject" },
+        { name: "Edit full message", value: "edit-full" },
+        { name: "Regenerate", value: "regenerate" },
+        { name: "Skip", value: "skip" },
+      ],
+    },
+  ]);
+  return action as ActionChoice;
+}
+
+async function promptSubjectEdit(subject: string): Promise<string> {
+  const { edited } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "edited",
+      default: subject,
+      message: "Edit subject (<=72 chars)",
+    },
+  ]);
+  return edited as string;
+}
+
+async function promptFullEdit(initial: string): Promise<string> {
+  const { edited } = await inquirer.prompt([
+    {
+      type: "editor",
+      name: "edited",
+      default: initial,
+      message: "Edit full commit message",
+    },
+  ]);
+  return edited as string;
+}
+
+async function promptBranch(cwd: string): Promise<string> {
+  const branches = getBranches(cwd);
+  const current = getCurrentBranch(cwd);
+  const baseChoices = branches
+    .filter((b) => b !== current)
+    .map((b) => ({ name: b, value: b }));
+
+  const choices = [
+    { name: `(current) ${current}`, value: current },
+    ...baseChoices,
+    { name: "Create new branch", value: "__create__" },
+  ];
+
+  const { branch } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "branch",
+      message: "Select branch for commit",
+      default: current,
+      choices,
+    },
+  ]);
+
+  if (branch === "__create__") {
+    const { name } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: "New branch name",
+        validate: (val: string) => (val && val.trim().length > 0 ? true : "Enter a branch name"),
+      },
+    ]);
+    createBranch(cwd, name.trim());
+    return name.trim();
+  }
+
+  if (branch !== current) {
+    checkoutBranch(cwd, branch);
+  }
+
+  return branch as string;
+}
+
+function renderSuggestion(message: string, showScore: boolean, diff: string) {
+  console.log("\n" + chalk.blue.bold("Piqnote suggestion:"));
+  console.log(chalk.green(message));
+
+  if (showScore) {
+    const insights = analyzeDiff(diff);
+    const score = scoreCommit(message, insights);
+    console.log("\n" + chalk.yellow(`Quality score: ${score.total}/100`));
+    score.details.forEach((item) => {
+      const label = chalk.gray("-");
+      console.log(`${label} ${item.label}: ${item.points} (${item.reason})`);
+    });
+  }
+}
+
+function formatWithFallback(
+  subject: string,
+  bullets: string[] | undefined,
+  insightsScope: string | undefined,
+  config: PiqnoteConfig,
+  stagedFiles: string[]
+): string {
+  const mergedBullets = ensureBullets(bullets, stagedFiles);
+  return formatCommit({ subject, bullets: mergedBullets, insightsScope }, config);
+}
+
+async function handleCommit(cwd: string, message: string, dryRun: boolean) {
+  if (dryRun) {
+    console.log(chalk.yellow("Dry-run: commit not created."));
+    return;
+  }
+  stageAll(cwd);
+  commitMessage(cwd, message);
+  console.log(chalk.green("Commit created."));
+}
+
+async function autoFlow(cwd: string, message: string, options: CliOptions, diff: string) {
+  renderSuggestion(message, options.score, diff);
+  await handleCommit(cwd, message, options.dryRun);
+}
+
+async function interactiveFlow(
+  cwd: string,
+  config: PiqnoteConfig,
+  options: CliOptions,
+  diff: string,
+  providerInput: {
+    subject: string;
+    bullets: string[];
+    insightsScope?: string;
+    regenerate: () => Promise<{ subject: string; bullets: string[] }>;
+  }
+) {
+  let message = formatWithFallback(
+    providerInput.subject,
+    providerInput.bullets,
+    providerInput.insightsScope,
+    config,
+    getStagedFiles(cwd)
+  );
+
+  let loop = true;
+  while (loop) {
+    renderSuggestion(message, options.score, diff);
+    const action = await promptAction();
+
+    if (action === "edit-subject") {
+      const subject = message.split("\n")[0];
+      const edited = await promptSubjectEdit(subject);
+      const rest = message.split("\n").slice(1);
+      message = [edited, ...rest].join("\n");
+      continue;
+    }
+
+    if (action === "edit-full") {
+      message = await promptFullEdit(message);
+      continue;
+    }
+
+    if (action === "regenerate") {
+      const next = await providerInput.regenerate();
+      message = formatWithFallback(next.subject, next.bullets, providerInput.insightsScope, config, getStagedFiles(cwd));
+      continue;
+    }
+
+    if (action === "accept-stage") {
+      stageAll(cwd);
+      console.log(chalk.green("Staged changes updated."));
+      loop = false;
+      continue;
+    }
+
+    if (action === "accept-commit") {
+      const branch = await promptBranch(cwd);
+      console.log(chalk.gray(`Using branch: ${branch}`));
+      await handleCommit(cwd, message, options.dryRun);
+      loop = false;
+      continue;
+    }
+
+    if (action === "skip") {
+      console.log("Skipped committing.");
+      loop = false;
+      continue;
+    }
+  }
+}
+
+async function main() {
+  const program = new Command();
+  program
+    .name("piqnote")
+    .description("Piqnote CLI by PromethIQ - generate commit messages")
+    .option("-i, --interactive", "Review interactively")
+    .option("--no-interactive", "Disable interactive review")
+    .option("--auto", "Commit automatically to current branch", false)
+    .option("--dry-run", "Show suggestions only; no commit", false)
+    .option("--score", "Show commit quality score", false)
+    .option("--offline", "Use offline heuristics", false)
+    .version("0.1.0");
+
+  program.parse(process.argv);
+  const raw = program.opts();
+  const options: CliOptions = {
+    interactive: raw.noInteractive ? false : raw.interactive ?? true,
+    score: Boolean(raw.score),
+    offline: Boolean(raw.offline),
+    auto: Boolean(raw.auto),
+    dryRun: Boolean(raw.dryRun),
+  };
+
+  const cwd = process.cwd();
+  if (!isGitRepo(cwd)) {
+    console.error("Piqnote: not a git repository.");
+    process.exit(1);
+  }
+
+  if (!hasStagedChanges(cwd)) {
+    console.error("Piqnote: no staged changes. Stage files first with 'git add'.");
+    process.exit(1);
+  }
+
+  const diff = getStagedDiff(cwd);
+  const config = loadConfig(cwd) || getDefaultConfig();
+  const insights = analyzeDiff(diff);
+  const provider = getProvider(config, { offline: options.offline || config.offline });
+  const stagedFiles = getStagedFiles(cwd);
+
+  const generate = async () => {
+    const res = await generateWithProvider(provider, {
+      diff,
+      insights,
+      language: config.language,
+      style: config.style,
+    });
+    return res;
+  };
+
+  const initial = await generate();
+  const formattedInitial = formatWithFallback(initial.subject, initial.bullets, insights.scope, config, stagedFiles);
+
+  if (!options.interactive || options.auto) {
+    await autoFlow(cwd, formattedInitial, options, diff);
+    return;
+  }
+
+  await interactiveFlow(cwd, config, options, diff, {
+    subject: initial.subject,
+    bullets: ensureBullets(initial.bullets, stagedFiles),
+    insightsScope: insights.scope,
+    regenerate: async () => {
+      const next = await generate();
+      return {
+        subject: next.subject,
+        bullets: ensureBullets(next.bullets, getStagedFiles(cwd)),
+      };
+    },
+  });
+}
+
+main().catch((error) => {
+  console.error("Piqnote failed:", error instanceof Error ? error.message : error);
+  process.exit(1);
+});

package/src/config/loader.ts

@@ -0,0 +1,36 @@
+import fs from "fs";
+import path from "path";
+import { PiqnoteConfig } from "./types";
+
+const defaultConfig: PiqnoteConfig = {
+  style: "conventional",
+  scope: undefined,
+  maxSubjectLength: 72,
+  language: "en",
+  bulletPrefix: "-",
+  provider: "mock",
+  offline: false,
+};
+
+export function loadConfig(cwd: string = process.cwd()): PiqnoteConfig {
+  const configPath = path.join(cwd, ".piqnoterc");
+  if (!fs.existsSync(configPath)) {
+    return defaultConfig;
+  }
+
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return {
+      ...defaultConfig,
+      ...parsed,
+    } as PiqnoteConfig;
+  } catch (error) {
+    console.warn("Piqnote: failed to parse .piqnoterc, using defaults.");
+    return defaultConfig;
+  }
+}
+
+export function getDefaultConfig(): PiqnoteConfig {
+  return { ...defaultConfig };
+}

package/src/config/types.ts

@@ -0,0 +1,11 @@
+export type CommitStyle = "conventional" | "plain";
+
+export interface PiqnoteConfig {
+  style: CommitStyle;
+  scope?: string;
+  maxSubjectLength: number;
+  language: string;
+  bulletPrefix: string;
+  provider: "mock" | "local" | "openai";
+  offline?: boolean;
+}

package/src/formatter/commitFormatter.ts

@@ -0,0 +1,37 @@
+import { PiqnoteConfig } from "../config/types";
+
+function truncate(text: string, max: number): string {
+  if (text.length <= max) return text;
+  return text.slice(0, max - 3).trimEnd() + "...";
+}
+
+function ensureConventional(subject: string, scope?: string): string {
+  const conventionalRegex = /^(feat|fix|chore|docs|refactor|test|perf|build|ci|style|revert)(\(.+\))?:/;
+  if (conventionalRegex.test(subject)) {
+    return subject;
+  }
+
+  const scoped = scope ? `chore(${scope}): ${subject}` : `chore: ${subject}`;
+  return scoped;
+}
+
+export interface CommitMessagePayload {
+  subject: string;
+  bullets: string[];
+  insightsScope?: string;
+}
+
+export function formatCommit(
+  payload: CommitMessagePayload,
+  config: PiqnoteConfig
+): string {
+  const baseSubject = truncate(payload.subject, config.maxSubjectLength || 72);
+  const scoped =
+    config.style === "conventional"
+      ? ensureConventional(baseSubject, config.scope || payload.insightsScope)
+      : baseSubject;
+  const bullets = payload.bullets?.length
+    ? payload.bullets.map((b) => `${config.bulletPrefix} ${b.trim()}`)
+    : [];
+  return [scoped, ...bullets].join("\n");
+}

package/src/git/gitClient.ts

@@ -0,0 +1,96 @@
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+
+function runGit(command: string, cwd: string): string {
+  try {
+    return execSync(`git ${command}`, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+    }).trim();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Git command failed: ${message}`);
+  }
+}
+
+export function isGitRepo(cwd: string): boolean {
+  try {
+    runGit("rev-parse --is-inside-work-tree", cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function hasStagedChanges(cwd: string): boolean {
+  try {
+    const output = runGit("diff --cached --name-only", cwd);
+    return output.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+export function getStagedDiff(cwd: string): string {
+  return runGit("diff --cached", cwd);
+}
+
+export function getStagedFiles(cwd: string): string[] {
+  try {
+    const output = runGit("diff --cached --name-only", cwd);
+    if (!output) return [];
+    return output.split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+export function stageAll(cwd: string): void {
+  runGit("add -A", cwd);
+}
+
+export function commitMessage(cwd: string, message: string): void {
+  const tempDir = fs.mkdtempSync(path.join(cwd, ".piqnote-"));
+  const filePath = path.join(tempDir, "message.txt");
+  fs.writeFileSync(filePath, message, "utf-8");
+  try {
+    runGit(`commit -F "${filePath}"`, cwd);
+  } finally {
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+
+export function getBranches(cwd: string): string[] {
+  try {
+    const output = runGit("branch --list --format='%(refname:short)'", cwd);
+    return output
+      .split("\n")
+      .map((b) => b.replace(/'/g, "").trim())
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+export function getCurrentBranch(cwd: string): string {
+  try {
+    const name = runGit("rev-parse --abbrev-ref HEAD", cwd);
+    if (name && name !== "HEAD") return name;
+  } catch {
+    /* fallthrough */
+  }
+  return "main";
+}
+
+export function checkoutBranch(cwd: string, branch: string): void {
+  runGit(`checkout ${branch}`, cwd);
+}
+
+export function createBranch(cwd: string, branch: string): void {
+  runGit(`checkout -b ${branch}`, cwd);
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}