piqnote 0.1.0

package/dist/config/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/formatter/commitFormatter.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCommit = formatCommit;
+function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    return text.slice(0, max - 3).trimEnd() + "...";
+}
+function ensureConventional(subject, scope) {
+    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;
+}
+function formatCommit(payload, config) {
+    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/dist/git/gitClient.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGitRepo = isGitRepo;
+exports.hasStagedChanges = hasStagedChanges;
+exports.getStagedDiff = getStagedDiff;
+exports.getStagedFiles = getStagedFiles;
+exports.stageAll = stageAll;
+exports.commitMessage = commitMessage;
+exports.getBranches = getBranches;
+exports.getCurrentBranch = getCurrentBranch;
+exports.checkoutBranch = checkoutBranch;
+exports.createBranch = createBranch;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function runGit(command, cwd) {
+    try {
+        return (0, child_process_1.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}`);
+    }
+}
+function isGitRepo(cwd) {
+    try {
+        runGit("rev-parse --is-inside-work-tree", cwd);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hasStagedChanges(cwd) {
+    try {
+        const output = runGit("diff --cached --name-only", cwd);
+        return output.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function getStagedDiff(cwd) {
+    return runGit("diff --cached", cwd);
+}
+function getStagedFiles(cwd) {
+    try {
+        const output = runGit("diff --cached --name-only", cwd);
+        if (!output)
+            return [];
+        return output.split("\n").filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+function stageAll(cwd) {
+    runGit("add -A", cwd);
+}
+function commitMessage(cwd, message) {
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(cwd, ".piqnote-"));
+    const filePath = path_1.default.join(tempDir, "message.txt");
+    fs_1.default.writeFileSync(filePath, message, "utf-8");
+    try {
+        runGit(`commit -F "${filePath}"`, cwd);
+    }
+    finally {
+        try {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch {
+        }
+    }
+}
+function getBranches(cwd) {
+    try {
+        const output = runGit("branch --list --format='%(refname:short)'", cwd);
+        return output
+            .split("\n")
+            .map((b) => b.replace(/'/g, "").trim())
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+function getCurrentBranch(cwd) {
+    try {
+        const name = runGit("rev-parse --abbrev-ref HEAD", cwd);
+        if (name && name !== "HEAD")
+            return name;
+    }
+    catch {
+        /* fallthrough */
+    }
+    return "main";
+}
+function checkoutBranch(cwd, branch) {
+    runGit(`checkout ${branch}`, cwd);
+}
+function createBranch(cwd, branch) {
+    runGit(`checkout -b ${branch}`, cwd);
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "piqnote",
+  "version": "0.1.0",
+  "description": "Piqnote CLI by PromethIQ - generate high-quality Git commit messages.",
+  "license": "AGPL-3.0-only",
+  "bin": {
+    "piqnote": "dist/cli.js"
+  },
+  "type": "commonjs",
+  "scripts": {
+    "build": "tsc -p .",
+    "start": "npm run build && node dist/cli.js",
+    "dev": "ts-node src/cli.ts",
+    "lint": "tsc --noEmit -p .",
+    "test": "npm run build",
+    "release:changelog": "npx release-please release-pr",
+    "release:tag": "npx release-please github-release"
+  },
+  "keywords": [
+    "git",
+    "commit",
+    "cli",
+    "conventional commits",
+    "promethiq",
+    "piqnote"
+  ],
+  "author": "Adam Kudlík",
+  "homepage": "https://github.com/promethiq/piqnote",
+  "bugs": {
+    "url": "https://github.com/promethiq/piqnote/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/promethiq/piqnote.git"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "inquirer": "^9.2.12"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^22.0.0",
+    "release-please": "^16.3.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/ai/factory.ts

@@ -0,0 +1,32 @@
+import { PiqnoteConfig } from "../config/types";
+import { AiProvider, AiRequest } from "./provider";
+import { MockAiProvider } from "./mockProvider";
+import { LocalAiProvider } from "./localProvider";
+import { OpenAiProvider } from "./openAiProvider";
+
+export interface ProviderOptions {
+  offline?: boolean;
+}
+
+export function getProvider(config: PiqnoteConfig, options: ProviderOptions = {}): AiProvider {
+  if (options.offline) {
+    return new MockAiProvider();
+  }
+
+  switch (config.provider) {
+    case "openai":
+      return new OpenAiProvider();
+    case "local":
+      return new LocalAiProvider();
+    case "mock":
+    default:
+      return new MockAiProvider();
+  }
+}
+
+export async function generateWithProvider(
+  provider: AiProvider,
+  request: AiRequest
+) {
+  return provider.generate(request);
+}

package/src/ai/localProvider.ts

@@ -0,0 +1,22 @@
+import { AiProvider, AiRequest, AiResponse } from "./provider";
+
+export class LocalAiProvider implements AiProvider {
+  public name = "local";
+
+  async generate(request: AiRequest): Promise<AiResponse> {
+    const { insights } = request;
+    const prefix = insights.scope ? `${insights.scope}: ` : "";
+    const subject = `${prefix}${insights.summary}`.slice(0, 72).trim();
+
+    const bullets = insights.bulletPoints.slice(0, 5).map((line) => line.replace(/^[+-]/, "").trim());
+
+    return {
+      subject,
+      bullets,
+      rationale: [
+        "Generated locally using diff insights and heuristics.",
+        `Scope: ${insights.scope || "n/a"}.`,
+      ],
+    };
+  }
+}

package/src/ai/mockProvider.ts

@@ -0,0 +1,30 @@
+import { AiProvider, AiRequest, AiResponse } from "./provider";
+
+const verbs = ["refine", "fix", "add", "improve", "update", "tune", "adjust", "harden"];
+
+function pickVerb(): string {
+  return verbs[Math.floor(Math.random() * verbs.length)];
+}
+
+export class MockAiProvider implements AiProvider {
+  public name = "mock";
+
+  async generate(request: AiRequest): Promise<AiResponse> {
+    const { insights } = request;
+    const primaryTopic = insights.topics[0] || "changes";
+    const verb = pickVerb();
+    const scopeHint = insights.scope ? `${insights.scope}: ` : "";
+    const subject = `${verb} ${scopeHint}${primaryTopic}`.trim();
+
+    const bullets = insights.bulletPoints.slice(0, 5).map((point) => {
+      return point.replace(/^[+\-]/, "").trim();
+    });
+
+    const rationale = [
+      `Used mock provider with heuristic verb '${verb}'.`,
+      `Scope hint: ${insights.scope || "none"}.`,
+    ];
+
+    return { subject, bullets, rationale };
+  }
+}

package/src/ai/openAiProvider.ts

@@ -0,0 +1,109 @@
+import { AiProvider, AiRequest, AiResponse } from "./provider";
+import { LocalAiProvider } from "./localProvider";
+
+interface OpenAiChatMessage {
+  role: "system" | "user" | "assistant";
+  content: string;
+}
+
+interface OpenAiChoice {
+  message: OpenAiChatMessage;
+}
+
+interface OpenAiResponse {
+  choices: OpenAiChoice[];
+}
+
+export class OpenAiProvider implements AiProvider {
+  public name = "openai";
+  private endpoint: string;
+  private apiKey: string;
+  private model: string;
+  private fallback = new LocalAiProvider();
+
+  constructor() {
+    this.endpoint = process.env.OPENAI_BASE_URL || "https://api.openai.com/v1/chat/completions";
+    this.apiKey = process.env.OPENAI_API_KEY || "";
+    this.model = process.env.OPENAI_MODEL || "gpt-4o-mini";
+  }
+
+  async generate(request: AiRequest): Promise<AiResponse> {
+    if (!this.apiKey) {
+      return this.fallback.generate(request);
+    }
+
+    const prompt = this.buildPrompt(request);
+
+    try {
+      const response = await fetch(this.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`,
+        },
+        body: JSON.stringify({
+          model: this.model,
+          temperature: 0.4,
+          messages: prompt,
+        }),
+      });
+
+      if (!response.ok) {
+        return this.fallback.generate(request);
+      }
+
+      const data = (await response.json()) as OpenAiResponse;
+      const content = data.choices?.[0]?.message?.content || "";
+      if (!content) {
+        return this.fallback.generate(request);
+      }
+
+      const parsed = this.parseContent(content);
+      return parsed || this.fallback.generate(request);
+    } catch {
+      return this.fallback.generate(request);
+    }
+  }
+
+  private buildPrompt(request: AiRequest): OpenAiChatMessage[] {
+    const { diff, insights, language, style } = request;
+    const scopeText = insights.scope ? `Scope: ${insights.scope}` : "";
+    return [
+      {
+        role: "system",
+        content:
+          "You are a commit message assistant. Generate a concise Git commit message with subject <=72 characters. Include optional bullet points. Use Conventional Commits if style=conventional. Be frontend-aware for React/CSS/UI changes.",
+      },
+      {
+        role: "user",
+        content: [
+          `Language: ${language}`,
+          `Style: ${style}`,
+          scopeText,
+          "Diff:",
+          diff.slice(0, 6000),
+        ]
+          .filter(Boolean)
+          .join("\n"),
+      },
+    ];
+  }
+
+  private parseContent(content: string): AiResponse | null {
+    const lines = content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    if (!lines.length) return null;
+
+    const subject = lines[0].replace(/^subject[:\-]\s*/i, "").slice(0, 72).trim();
+    const bullets = lines
+      .slice(1)
+      .filter((line) => /^[-*•]/.test(line))
+      .map((line) => line.replace(/^[-*•]\s*/, "").trim())
+      .slice(0, 5);
+
+    return {
+      subject: subject || lines[0].slice(0, 72),
+      bullets,
+      rationale: ["Generated via OpenAI"],
+    };
+  }
+}

package/src/ai/provider.ts

@@ -0,0 +1,19 @@
+import { DiffInsights } from "../analyzer/diffAnalyzer";
+
+export interface AiRequest {
+  diff: string;
+  insights: DiffInsights;
+  language: string;
+  style: string;
+}
+
+export interface AiResponse {
+  subject: string;
+  bullets: string[];
+  rationale?: string[];
+}
+
+export interface AiProvider {
+  name: string;
+  generate(request: AiRequest): Promise<AiResponse>;
+}

package/src/analyzer/diffAnalyzer.ts

@@ -0,0 +1,96 @@
+export interface DiffInsights {
+  scope?: string;
+  topics: string[];
+  bulletPoints: string[];
+  summary: string;
+  isFrontend: boolean;
+  filesTouched: number;
+}
+
+function extractFilePaths(diff: string): string[] {
+  return diff
+    .split("\n")
+    .filter((line) => line.startsWith("+++ b/") || line.startsWith("--- a/"))
+    .map((line) => line.replace("+++ b/", "").replace("--- a/", ""))
+    .filter(Boolean);
+}
+
+function detectScopeFromPaths(paths: string[]): string | undefined {
+  const frontendExtensions = [".ts", ".tsx", ".js", ".jsx", ".css", ".scss", ".sass", ".vue"];
+  const apiIndicators = ["api", "server", "backend", "routes", "controllers"];
+  const configIndicators = ["config", "settings", "env", "build", "webpack", "vite"];
+
+  for (const file of paths) {
+    const lower = file.toLowerCase();
+    if (frontendExtensions.some((ext) => lower.endsWith(ext))) {
+      if (lower.includes("component") || lower.includes("ui")) {
+        return "ui";
+      }
+      return "front";
+    }
+    if (apiIndicators.some((keyword) => lower.includes(keyword))) {
+      return "api";
+    }
+    if (configIndicators.some((keyword) => lower.includes(keyword))) {
+      return "build";
+    }
+  }
+  return undefined;
+}
+
+function extractAddedRemovedLines(diff: string): string[] {
+  return diff
+    .split("\n")
+    .filter((line) => line.startsWith("+") || line.startsWith("-"))
+    .filter((line) => !line.startsWith("+++"))
+    .filter((line) => !line.startsWith("---"))
+    .map((line) => line.substring(1).trim())
+    .filter(Boolean);
+}
+
+function pickTopTopics(lines: string[], limit: number = 3): string[] {
+  const keywordCount = new Map<string, number>();
+  for (const line of lines) {
+    const words = line
+      .replace(/[^a-zA-Z0-9_ ]/g, " ")
+      .split(/\s+/)
+      .filter(Boolean)
+      .map((w) => w.toLowerCase())
+      .filter((w) => w.length > 3 && w.length < 30);
+    for (const word of words) {
+      keywordCount.set(word, (keywordCount.get(word) || 0) + 1);
+    }
+  }
+  return Array.from(keywordCount.entries())
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, limit)
+    .map(([word]) => word);
+}
+
+function buildSummary(topics: string[], scope?: string): string {
+  const topicText = topics.length ? topics.join(", ") : "changes";
+  if (scope) {
+    return `${scope} updates: ${topicText}`;
+  }
+  return `Updates around ${topicText}`;
+}
+
+export function analyzeDiff(diff: string): DiffInsights {
+  const files = extractFilePaths(diff);
+  const scope = detectScopeFromPaths(files);
+  const lines = extractAddedRemovedLines(diff);
+  const topics = pickTopTopics(lines, 4);
+  const bulletPoints = lines.slice(0, 5).map((line) => line.slice(0, 80));
+  const summary = buildSummary(topics, scope);
+  const frontendExtensions = [".tsx", ".jsx", ".css", ".scss", ".sass", ".vue"];
+  const isFrontend = files.some((file) => frontendExtensions.some((ext) => file.toLowerCase().endsWith(ext)));
+
+  return {
+    scope,
+    topics,
+    bulletPoints,
+    summary,
+    isFrontend,
+    filesTouched: files.length,
+  };
+}

package/src/analyzer/scorer.ts

@@ -0,0 +1,68 @@
+import { DiffInsights } from "./diffAnalyzer";
+
+export interface ScoreDetail {
+  label: string;
+  points: number;
+  reason: string;
+}
+
+export interface CommitScore {
+  total: number;
+  details: ScoreDetail[];
+}
+
+function isImperative(subject: string): boolean {
+  const firstWord = subject.trim().split(/\s+/)[0]?.toLowerCase();
+  if (!firstWord) return false;
+  const blacklist = ["fixes", "fixed", "fixing", "adds", "added", "adding", "updates", "updated"];
+  return !blacklist.includes(firstWord) && !subject.toLowerCase().includes("please");
+}
+
+export function scoreCommit(message: string, insights: DiffInsights): CommitScore {
+  const details: ScoreDetail[] = [];
+  const subject = message.split("\n")[0];
+
+  if (subject.length <= 72) {
+    details.push({ label: "Subject length", points: 20, reason: "Within 72 characters" });
+  } else {
+    details.push({ label: "Subject length", points: 5, reason: "Too long" });
+  }
+
+  if (isImperative(subject)) {
+    details.push({ label: "Imperative mood", points: 15, reason: "Starts with a verb" });
+  } else {
+    details.push({ label: "Imperative mood", points: 5, reason: "Consider imperative verb" });
+  }
+
+  if (message.includes("feat:") || message.includes("fix:") || message.includes("chore:") || message.includes("refactor:")) {
+    details.push({ label: "Conventional style", points: 15, reason: "Uses Conventional Commits" });
+  } else {
+    details.push({ label: "Conventional style", points: 5, reason: "Add a type prefix" });
+  }
+
+  const bulletLines = message.split("\n").filter((line) => line.trim().startsWith("-"));
+  if (bulletLines.length > 0) {
+    details.push({ label: "Bullets", points: 15, reason: "Includes bullet points" });
+  } else {
+    details.push({ label: "Bullets", points: 5, reason: "Add bullets for clarity" });
+  }
+
+  if (insights.isFrontend) {
+    details.push({ label: "Frontend awareness", points: 10, reason: "Mentions UI-related changes" });
+  } else {
+    details.push({ label: "Frontend awareness", points: 8, reason: "General changes" });
+  }
+
+  if (insights.filesTouched > 3) {
+    details.push({ label: "Scope breadth", points: 8, reason: "Multiple files" });
+  } else {
+    details.push({ label: "Scope breadth", points: 6, reason: "Focused change" });
+  }
+
+  const total = Math.min(
+    100,
+    details.reduce((sum, item) => sum + item.points, 0)
+  );
+
+  return { total, details };
+}