piqnote 0.1.0

package/README.md

@@ -0,0 +1,106 @@
+# Piqnote CLI by PromethIQ
+
+[![License: AGPL-3.0](https://img.shields.io/badge/License-AGPL--3.0-blue.svg)](LICENSE)
+[![Build](https://img.shields.io/github/actions/workflow/status/promethiq/piqnote/ci.yml?label=ci)](https://github.com/promethiq/piqnote/actions)
+[![NPM Version](https://img.shields.io/npm/v/piqnote.svg)](https://www.npmjs.com/package/piqnote)
+
+Piqnote is an AGPL-licensed, frontend-aware Git commit message generator by PromethIQ. It supports Conventional Commits, interactive review, commit quality scoring, offline heuristics, and optional auto-commit workflows.
+
+## Features
+- Generates concise subjects (<=72 chars) with optional bullets (staged files fallback)
+- Conventional Commits with configurable scope
+- Interactive menu: Edit subject, Edit full message, Regenerate, Accept & commit, Accept & stage, Skip
+- Commit quality scoring
+- Branch selection and new branch creation before commit
+- Offline/local/mock providers with AI abstraction (OpenAI/local/mock)
+- Works on staged changes via `git diff --staged`
+- Auto-commit mode (`--auto`) and dry-run mode (`--dry-run`)
+
+## Installation
+```bash
+git clone https://github.com/promethiq/piqnote.git
+cd piqnote
+npm install
+npm run build
+npm install -g .
+```
+
+## Usage
+```bash
+git add .
+piqnote --interactive --score
+```
+
+CLI options:
+- `--interactive` / `--no-interactive`
+- `--auto` commit automatically to current branch
+- `--dry-run` show suggestions only, no commit
+- `--score` show quality score breakdown
+- `--offline` force offline/mock provider
+- `--help` show all commands and options
+
+Non-interactive examples:
+```bash
+piqnote --no-interactive
+piqnote --auto --score
+piqnote --auto --dry-run
+```
+
+Interactive workflow actions:
+- Edit subject (inline)
+- Edit full message (editor)
+- Regenerate suggestion
+- Accept and stage only
+- Accept and commit (choose branch or create new)
+- Skip
+
+## Configuration
+Create a `.piqnoterc` in your repo root:
+```json
+{
+  "style": "conventional",
+  "scope": "web",
+  "maxSubjectLength": 72,
+  "language": "en",
+  "bulletPrefix": "-",
+  "provider": "mock",
+  "offline": false
+}
+```
+
+Environment (optional for OpenAI provider):
+- OPENAI_API_KEY
+- OPENAI_MODEL (default: gpt-4o-mini)
+- OPENAI_BASE_URL (optional)
+
+## Project Structure
+```
+src/
+  cli.ts
+  ai/
+  analyzer/
+  formatter/
+  git/
+  config/
+.github/workflows/ci.yml
+.piqnoterc
+CHANGELOG.md
+LICENSE
+README.md
+```
+
+## Versioning and Releases
+- Semantic Versioning (semver), starting at 0.1.0
+- CHANGELOG maintained by CI via release-please
+- GitHub Actions pipeline builds, lints, tests, and can publish on tagged releases
+
+## CI/CD
+- Install dependencies
+- TypeScript lint/build
+- Tests
+- Release automation to update CHANGELOG and create GitHub releases (optional npm publish with token)
+
+## License and Branding
+- License: AGPL-3.0 (see [LICENSE](LICENSE))
+- Project: Piqnote - by PromethIQ
+- Maintainer: Adam Kudlík

package/dist/ai/factory.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProvider = getProvider;
+exports.generateWithProvider = generateWithProvider;
+const mockProvider_1 = require("./mockProvider");
+const localProvider_1 = require("./localProvider");
+const openAiProvider_1 = require("./openAiProvider");
+function getProvider(config, options = {}) {
+    if (options.offline) {
+        return new mockProvider_1.MockAiProvider();
+    }
+    switch (config.provider) {
+        case "openai":
+            return new openAiProvider_1.OpenAiProvider();
+        case "local":
+            return new localProvider_1.LocalAiProvider();
+        case "mock":
+        default:
+            return new mockProvider_1.MockAiProvider();
+    }
+}
+async function generateWithProvider(provider, request) {
+    return provider.generate(request);
+}

package/dist/ai/localProvider.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalAiProvider = void 0;
+class LocalAiProvider {
+    constructor() {
+        this.name = "local";
+    }
+    async generate(request) {
+        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"}.`,
+            ],
+        };
+    }
+}
+exports.LocalAiProvider = LocalAiProvider;

package/dist/ai/mockProvider.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockAiProvider = void 0;
+const verbs = ["refine", "fix", "add", "improve", "update", "tune", "adjust", "harden"];
+function pickVerb() {
+    return verbs[Math.floor(Math.random() * verbs.length)];
+}
+class MockAiProvider {
+    constructor() {
+        this.name = "mock";
+    }
+    async generate(request) {
+        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 };
+    }
+}
+exports.MockAiProvider = MockAiProvider;

package/dist/ai/openAiProvider.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAiProvider = void 0;
+const localProvider_1 = require("./localProvider");
+class OpenAiProvider {
+    constructor() {
+        this.name = "openai";
+        this.fallback = new localProvider_1.LocalAiProvider();
+        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) {
+        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());
+            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);
+        }
+    }
+    buildPrompt(request) {
+        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"),
+            },
+        ];
+    }
+    parseContent(content) {
+        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"],
+        };
+    }
+}
+exports.OpenAiProvider = OpenAiProvider;

package/dist/ai/provider.js

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

package/dist/analyzer/diffAnalyzer.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeDiff = analyzeDiff;
+function extractFilePaths(diff) {
+    return diff
+        .split("\n")
+        .filter((line) => line.startsWith("+++ b/") || line.startsWith("--- a/"))
+        .map((line) => line.replace("+++ b/", "").replace("--- a/", ""))
+        .filter(Boolean);
+}
+function detectScopeFromPaths(paths) {
+    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) {
+    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, limit = 3) {
+    const keywordCount = new Map();
+    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, scope) {
+    const topicText = topics.length ? topics.join(", ") : "changes";
+    if (scope) {
+        return `${scope} updates: ${topicText}`;
+    }
+    return `Updates around ${topicText}`;
+}
+function analyzeDiff(diff) {
+    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/dist/analyzer/scorer.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scoreCommit = scoreCommit;
+function isImperative(subject) {
+    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");
+}
+function scoreCommit(message, insights) {
+    const details = [];
+    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 };
+}

package/dist/cli.js

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const loader_1 = require("./config/loader");
+const diffAnalyzer_1 = require("./analyzer/diffAnalyzer");
+const scorer_1 = require("./analyzer/scorer");
+const commitFormatter_1 = require("./formatter/commitFormatter");
+const factory_1 = require("./ai/factory");
+const gitClient_1 = require("./git/gitClient");
+function ensureBullets(responseBullets, stagedFiles) {
+    if (responseBullets && responseBullets.length)
+        return responseBullets;
+    return stagedFiles.slice(0, 5).map((file) => file);
+}
+async function promptAction() {
+    const { action } = await inquirer_1.default.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;
+}
+async function promptSubjectEdit(subject) {
+    const { edited } = await inquirer_1.default.prompt([
+        {
+            type: "input",
+            name: "edited",
+            default: subject,
+            message: "Edit subject (<=72 chars)",
+        },
+    ]);
+    return edited;
+}
+async function promptFullEdit(initial) {
+    const { edited } = await inquirer_1.default.prompt([
+        {
+            type: "editor",
+            name: "edited",
+            default: initial,
+            message: "Edit full commit message",
+        },
+    ]);
+    return edited;
+}
+async function promptBranch(cwd) {
+    const branches = (0, gitClient_1.getBranches)(cwd);
+    const current = (0, gitClient_1.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_1.default.prompt([
+        {
+            type: "list",
+            name: "branch",
+            message: "Select branch for commit",
+            default: current,
+            choices,
+        },
+    ]);
+    if (branch === "__create__") {
+        const { name } = await inquirer_1.default.prompt([
+            {
+                type: "input",
+                name: "name",
+                message: "New branch name",
+                validate: (val) => (val && val.trim().length > 0 ? true : "Enter a branch name"),
+            },
+        ]);
+        (0, gitClient_1.createBranch)(cwd, name.trim());
+        return name.trim();
+    }
+    if (branch !== current) {
+        (0, gitClient_1.checkoutBranch)(cwd, branch);
+    }
+    return branch;
+}
+function renderSuggestion(message, showScore, diff) {
+    console.log("\n" + chalk_1.default.blue.bold("Piqnote suggestion:"));
+    console.log(chalk_1.default.green(message));
+    if (showScore) {
+        const insights = (0, diffAnalyzer_1.analyzeDiff)(diff);
+        const score = (0, scorer_1.scoreCommit)(message, insights);
+        console.log("\n" + chalk_1.default.yellow(`Quality score: ${score.total}/100`));
+        score.details.forEach((item) => {
+            const label = chalk_1.default.gray("-");
+            console.log(`${label} ${item.label}: ${item.points} (${item.reason})`);
+        });
+    }
+}
+function formatWithFallback(subject, bullets, insightsScope, config, stagedFiles) {
+    const mergedBullets = ensureBullets(bullets, stagedFiles);
+    return (0, commitFormatter_1.formatCommit)({ subject, bullets: mergedBullets, insightsScope }, config);
+}
+async function handleCommit(cwd, message, dryRun) {
+    if (dryRun) {
+        console.log(chalk_1.default.yellow("Dry-run: commit not created."));
+        return;
+    }
+    (0, gitClient_1.stageAll)(cwd);
+    (0, gitClient_1.commitMessage)(cwd, message);
+    console.log(chalk_1.default.green("Commit created."));
+}
+async function autoFlow(cwd, message, options, diff) {
+    renderSuggestion(message, options.score, diff);
+    await handleCommit(cwd, message, options.dryRun);
+}
+async function interactiveFlow(cwd, config, options, diff, providerInput) {
+    let message = formatWithFallback(providerInput.subject, providerInput.bullets, providerInput.insightsScope, config, (0, gitClient_1.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, (0, gitClient_1.getStagedFiles)(cwd));
+            continue;
+        }
+        if (action === "accept-stage") {
+            (0, gitClient_1.stageAll)(cwd);
+            console.log(chalk_1.default.green("Staged changes updated."));
+            loop = false;
+            continue;
+        }
+        if (action === "accept-commit") {
+            const branch = await promptBranch(cwd);
+            console.log(chalk_1.default.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 commander_1.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 = {
+        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 (!(0, gitClient_1.isGitRepo)(cwd)) {
+        console.error("Piqnote: not a git repository.");
+        process.exit(1);
+    }
+    if (!(0, gitClient_1.hasStagedChanges)(cwd)) {
+        console.error("Piqnote: no staged changes. Stage files first with 'git add'.");
+        process.exit(1);
+    }
+    const diff = (0, gitClient_1.getStagedDiff)(cwd);
+    const config = (0, loader_1.loadConfig)(cwd) || (0, loader_1.getDefaultConfig)();
+    const insights = (0, diffAnalyzer_1.analyzeDiff)(diff);
+    const provider = (0, factory_1.getProvider)(config, { offline: options.offline || config.offline });
+    const stagedFiles = (0, gitClient_1.getStagedFiles)(cwd);
+    const generate = async () => {
+        const res = await (0, factory_1.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, (0, gitClient_1.getStagedFiles)(cwd)),
+            };
+        },
+    });
+}
+main().catch((error) => {
+    console.error("Piqnote failed:", error instanceof Error ? error.message : error);
+    process.exit(1);
+});

package/dist/config/loader.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.getDefaultConfig = getDefaultConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const defaultConfig = {
+    style: "conventional",
+    scope: undefined,
+    maxSubjectLength: 72,
+    language: "en",
+    bulletPrefix: "-",
+    provider: "mock",
+    offline: false,
+};
+function loadConfig(cwd = process.cwd()) {
+    const configPath = path_1.default.join(cwd, ".piqnoterc");
+    if (!fs_1.default.existsSync(configPath)) {
+        return defaultConfig;
+    }
+    try {
+        const raw = fs_1.default.readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return {
+            ...defaultConfig,
+            ...parsed,
+        };
+    }
+    catch (error) {
+        console.warn("Piqnote: failed to parse .piqnoterc, using defaults.");
+        return defaultConfig;
+    }
+}
+function getDefaultConfig() {
+    return { ...defaultConfig };
+}