depfix-ai 0.1.2 → 0.2.2

package/README.md

@@ -0,0 +1,146 @@
+# depfix-ai
+
+[![npm version](https://img.shields.io/npm/v/depfix-ai.svg)](https://www.npmjs.com/package/depfix-ai)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+> CLI for dependency audit, env file generation, and contributor onboarding. Fix your deps, generate `.env.example`, and get projects ready in one command.
+
+**Requires Node.js ≥ 18.**
+
+---
+
+## Install
+
+**Global (npm or pnpm):**
+
+```bash
+npm install -g depfix-ai
+# or
+pnpm add -g depfix-ai
+```
+
+**Run without installing (npx / pnpm dlx):**
+
+```bash
+npx depfix-ai --help
+# or
+pnpm dlx depfix-ai --help
+```
+
+---
+
+## Quick start
+
+After installing globally or with `npx` / `pnpm dlx`:
+
+```bash
+depfix-ai audit              # Security audit + human summary
+depfix-ai env generate       # Scan source → .env.example
+depfix-ai onboard            # Install deps + env + tests
+depfix-ai fix                # Preview fixes (dry-run); use --apply to apply
+```
+
+One-off (no install):
+
+```bash
+npx depfix-ai audit
+pnpm dlx depfix-ai env generate
+```
+
+---
+
+## Commands
+
+### `depfix-ai audit`
+
+Run a security audit and get a human-readable summary (npm only for now).
+
+| Flag | Description |
+|------|-------------|
+| `--json` | Print raw npm audit JSON |
+| `--severity <level>` | `low` \| `moderate` \| `high` \| `critical` (default: low) |
+| `--fail` | Exit 1 if vulnerabilities ≥ severity |
+
+```bash
+depfix-ai audit
+depfix-ai audit --severity high --fail
+depfix-ai audit --json
+```
+
+---
+
+### `depfix-ai env generate`
+
+Scan source for `process.env.*` and `import.meta.env.*`; generate grouped `.env.example` (and optionally a blank `.env`).
+
+| Flag | Description |
+|------|-------------|
+| `--out <path>` | Output file (default: .env.example) |
+| `--create` | Create .env with blank values if missing |
+| `--force` | Overwrite .env when used with --create |
+| `--check` | Verify .env.example has all vars; exit 1 if not |
+
+```bash
+depfix-ai env generate
+depfix-ai env generate --create
+depfix-ai env generate --check
+```
+
+---
+
+### `depfix-ai fix`
+
+Preview dependency fixes (dry-run by default). Use `--apply` to write changes.
+
+| Flag | Description |
+|------|-------------|
+| `--apply` | Apply changes |
+| `--force` | Pass --force to npm audit fix |
+| `--stash` | Auto-stash if git dirty |
+| `--commit` | Auto-commit with chore(deps): audit fix |
+| `--dry-run` | Preview only (default) |
+
+```bash
+depfix-ai fix
+depfix-ai fix --apply
+```
+
+---
+
+### `depfix-ai onboard`
+
+One-command setup: backup (git stash), install deps, env generate, run tests.
+
+| Flag | Description |
+|------|-------------|
+| `--skip-install` | Skip npm install |
+| `--skip-env` | Skip env generate |
+| `--skip-test` | Skip test script |
+
+```bash
+depfix-ai onboard
+depfix-ai onboard --skip-test
+```
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/hesxo/depfix-ai.git
+cd depfix-ai
+npm ci
+# or: pnpm install
+npm run build
+npm test
+```
+
+**Scripts:** `build` · `test` · `lint` · `version:patch`
+
+---
+
+## License
+
+MIT
+
+lol

package/dist/commands/audit.d.ts

@@ -0,0 +1,12 @@
+import { Command } from "@oclif/core";
+export default class Audit extends Command {
+    static readonly id = "audit";
+    static readonly description = "Audit dependencies and summarize vulnerabilities (npm only for now).";
+    static readonly flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        severity: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        fail: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=audit.d.ts.map

package/dist/commands/audit.js

@@ -0,0 +1,66 @@
+import { Command, Flags } from "@oclif/core";
+import { runNpmAuditJson } from "../lib/audit/npmAudit.js";
+import { printAuditSummary, summarizeNpmAudit, } from "../lib/audit/summarize.js";
+import { logError, logInfo } from "../lib/ui/log.js";
+function normalizeSeverity(s) {
+    if (s && ["low", "moderate", "high", "critical"].includes(s))
+        return s;
+    return "low";
+}
+export default class Audit extends Command {
+    static id = "audit";
+    static description = "Audit dependencies and summarize vulnerabilities (npm only for now).";
+    static flags = {
+        json: Flags.boolean({
+            description: "Print raw npm audit JSON to stdout",
+        }),
+        severity: Flags.string({
+            description: "Minimum severity to include",
+            options: ["low", "moderate", "high", "critical"],
+            default: "low",
+        }),
+        fail: Flags.boolean({
+            description: "Exit with code 1 if vulnerabilities at or above --severity exist",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Audit);
+        const severity = normalizeSeverity(flags.severity);
+        const { pm, rawJson, exitCode } = await runNpmAuditJson();
+        if (pm !== "npm") {
+            logInfo(`Audit is only implemented for npm right now. Detected ${pm}.`);
+            return;
+        }
+        if (!rawJson) {
+            logError("npm audit did not return JSON output.");
+            if (typeof exitCode === "number")
+                this.exit(exitCode);
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(rawJson);
+        }
+        catch {
+            logError("Failed to parse npm audit JSON output.");
+            if (flags.json)
+                console.log(rawJson);
+            if (typeof exitCode === "number")
+                this.exit(exitCode);
+            return;
+        }
+        const summaryOptions = { minSeverity: severity };
+        const summary = summarizeNpmAudit(parsed, summaryOptions);
+        printAuditSummary(summary);
+        if (flags.json)
+            console.log(rawJson);
+        if (flags.fail) {
+            const hasIssues = summary.counts.critical > 0 ||
+                (severity !== "critical" && summary.counts.high > 0) ||
+                (["low", "moderate"].includes(severity) && summary.counts.moderate > 0) ||
+                (severity === "low" && summary.counts.low > 0);
+            if (hasIssues)
+                this.exit(1);
+        }
+    }
+}

package/dist/commands/env/generate.d.ts

@@ -0,0 +1,16 @@
+import { Command } from "@oclif/core";
+export default class EnvGenerate extends Command {
+    static readonly id = "env:generate";
+    static readonly description = "Generate .env.example from detected environment variable usage in source.";
+    static readonly flags: {
+        out: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        create: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        check: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        ai: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        model: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "api-key": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=generate.d.ts.map

package/dist/commands/env/generate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/commands/env/generate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAS,MAAM,aAAa,CAAC;AAG7C,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,OAAO;IAC9C,MAAM,CAAC,QAAQ,CAAC,EAAE,kBAAkB;IACpC,MAAM,CAAC,QAAQ,CAAC,WAAW,+EACmD;IAE9E,MAAM,CAAC,QAAQ,CAAC,KAAK;;;;;MAcnB;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAS3B"}
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/commands/env/generate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAS,MAAM,aAAa,CAAC;AAG7C,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,OAAO;IAC9C,MAAM,CAAC,QAAQ,CAAC,EAAE,kBAAkB;IACpC,MAAM,CAAC,QAAQ,CAAC,WAAW,+EACmD;IAE9E,MAAM,CAAC,QAAQ,CAAC,KAAK;;;;;;;;MA0BnB;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAY3B"}

package/dist/commands/env/generate.js

@@ -0,0 +1,45 @@
+import { Command, Flags } from "@oclif/core";
+import { runEnvGenerate } from "../../lib/env/write.js";
+export default class EnvGenerate extends Command {
+    static id = "env:generate";
+    static description = "Generate .env.example from detected environment variable usage in source.";
+    static flags = {
+        out: Flags.string({
+            description: "Output path for example file",
+            default: ".env.example",
+        }),
+        create: Flags.boolean({
+            description: "Create .env with blank values if missing",
+        }),
+        force: Flags.boolean({
+            description: "Overwrite existing outputs (e.g. .env when used with --create)",
+        }),
+        check: Flags.boolean({
+            description: "Verify .env.example contains all required vars; exit 1 if not",
+        }),
+        ai: Flags.boolean({
+            description: "Use OpenAI to add descriptions and where-to-get for each variable",
+            default: false,
+        }),
+        model: Flags.string({
+            description: "OpenAI model for AI mode (e.g. gpt-4o-mini)",
+            default: "gpt-4o-mini",
+        }),
+        "api-key": Flags.string({
+            description: "OpenAI API key (default: OPENAI_API_KEY env)",
+            env: "OPENAI_API_KEY",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(EnvGenerate);
+        await runEnvGenerate({
+            out: flags.out,
+            create: flags.create,
+            force: flags.force,
+            check: flags.check,
+            ai: flags.ai,
+            model: flags.model,
+            apiKey: flags["api-key"] ?? "",
+        });
+    }
+}

package/dist/commands/fix.d.ts

@@ -0,0 +1,14 @@
+import { Command } from "@oclif/core";
+export default class Fix extends Command {
+    static readonly id = "fix";
+    static readonly description = "Preview and apply dependency fixes safely (dry-run by default).";
+    static readonly flags: {
+        apply: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        stash: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        commit: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "dry-run": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=fix.d.ts.map

package/dist/commands/fix.js

@@ -0,0 +1,33 @@
+import { Command, Flags } from "@oclif/core";
+import { runFix } from "../lib/audit/summarize.js";
+export default class Fix extends Command {
+    static id = "fix";
+    static description = "Preview and apply dependency fixes safely (dry-run by default).";
+    static flags = {
+        apply: Flags.boolean({
+            description: "Actually apply changes (default: dry-run only)",
+        }),
+        force: Flags.boolean({
+            description: "Pass --force to npm audit fix",
+        }),
+        stash: Flags.boolean({
+            description: "Auto-stash if git working tree is dirty",
+        }),
+        commit: Flags.boolean({
+            description: "Auto-commit changes with chore(deps): audit fix",
+        }),
+        "dry-run": Flags.boolean({
+            description: "Preview only; do not write files (default: true)",
+            default: true,
+            allowNo: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Fix);
+        // v0.1: placeholder; full implementation will use dry-run default, backups, diff preview
+        if (flags["dry-run"] !== false && !flags.apply) {
+            this.log("Dry-run: no changes will be written. Use --apply to apply fixes.");
+        }
+        await runFix();
+    }
+}

package/dist/commands/onboard.d.ts

@@ -0,0 +1,12 @@
+import { Command } from "@oclif/core";
+export default class Onboard extends Command {
+    static readonly id = "onboard";
+    static readonly description = "Run contributor onboarding: install deps, generate env, run tests.";
+    static readonly flags: {
+        "skip-install": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "skip-env": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "skip-test": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=onboard.d.ts.map

package/dist/commands/onboard.js

@@ -0,0 +1,25 @@
+import { Command, Flags } from "@oclif/core";
+import { runOnboard } from "../lib/safety/backup.js";
+export default class Onboard extends Command {
+    static id = "onboard";
+    static description = "Run contributor onboarding: install deps, generate env, run tests.";
+    static flags = {
+        "skip-install": Flags.boolean({
+            description: "Skip dependency install",
+        }),
+        "skip-env": Flags.boolean({
+            description: "Skip env generate",
+        }),
+        "skip-test": Flags.boolean({
+            description: "Skip test script",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Onboard);
+        await runOnboard({
+            skipInstall: flags["skip-install"],
+            skipEnv: flags["skip-env"],
+            skipTest: flags["skip-test"],
+        });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export declare const version: string;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,OAAO,QAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,OAAO,QAAyB,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf8"));
+export const version = pkg.version ?? "0.0.0";

package/dist/lib/audit/npmAudit.d.ts

@@ -0,0 +1,13 @@
+export interface NpmAuditResult {
+    pm: "npm" | string;
+    rawJson: string | undefined;
+    exitCode: number | undefined;
+}
+/**
+ * Run an npm audit in JSON mode.
+ *
+ * For v0.1.0 we only support npm; if another package manager
+ * is detected we return early without running anything.
+ */
+export declare function runNpmAuditJson(cwd?: string): Promise<NpmAuditResult>;
+//# sourceMappingURL=npmAudit.d.ts.map

package/dist/lib/audit/npmAudit.js

@@ -0,0 +1,22 @@
+import { detectPackageManager } from "../pm/detect.js";
+import { runPmCommand } from "../pm/run.js";
+/**
+ * Run an npm audit in JSON mode.
+ *
+ * For v0.1.0 we only support npm; if another package manager
+ * is detected we return early without running anything.
+ */
+export async function runNpmAuditJson(cwd = process.cwd()) {
+    const pm = detectPackageManager(cwd);
+    if (pm !== "npm") {
+        return { pm, rawJson: undefined, exitCode: undefined };
+    }
+    const { stdout, exitCode } = await runPmCommand(pm, ["audit", "--json"], {
+        cwd,
+    });
+    return {
+        pm,
+        rawJson: stdout,
+        exitCode,
+    };
+}

package/dist/lib/audit/summarize.d.ts

@@ -0,0 +1,30 @@
+export type Severity = "low" | "moderate" | "high" | "critical";
+export interface AuditSummaryOptions {
+    /**
+     * Minimum severity to include in the summary.
+     * Vulnerabilities below this level will be ignored.
+     */
+    minSeverity?: Severity;
+}
+export interface SeverityCounts {
+    low: number;
+    moderate: number;
+    high: number;
+    critical: number;
+}
+export interface PackageImpact {
+    name: string;
+    count: number;
+}
+export interface AuditSummary {
+    counts: SeverityCounts;
+    impactedPackages: PackageImpact[];
+}
+/**
+ * Normalise npm audit JSON into a simple summary that is reasonably
+ * robust across npm versions (v6/v7+).
+ */
+export declare function summarizeNpmAudit(data: unknown, options?: AuditSummaryOptions): AuditSummary;
+export declare function printAuditSummary(summary: AuditSummary): void;
+export declare function runFix(): Promise<void>;
+//# sourceMappingURL=summarize.d.ts.map

package/dist/lib/audit/summarize.js

@@ -0,0 +1,79 @@
+import { logInfo } from "../ui/log.js";
+const severityOrder = ["low", "moderate", "high", "critical"];
+function severityAtLeast(a, min) {
+    return severityOrder.indexOf(a) >= severityOrder.indexOf(min);
+}
+function emptyCounts() {
+    return { low: 0, moderate: 0, high: 0, critical: 0 };
+}
+/**
+ * Normalise npm audit JSON into a simple summary that is reasonably
+ * robust across npm versions (v6/v7+).
+ */
+export function summarizeNpmAudit(data, options = {}) {
+    const minSeverity = options.minSeverity ?? "low";
+    const counts = emptyCounts();
+    const pkgCounts = new Map();
+    const anyData = data;
+    // Prefer the modern `vulnerabilities` shape if present.
+    if (anyData && typeof anyData === "object" && anyData.vulnerabilities) {
+        const vulns = anyData.vulnerabilities;
+        for (const [pkgName, vuln] of Object.entries(vulns)) {
+            const severity = vuln.severity;
+            if (!severity || !severityAtLeast(severity, minSeverity))
+                continue;
+            counts[severity] += 1;
+            pkgCounts.set(pkgName, (pkgCounts.get(pkgName) ?? 0) + 1);
+        }
+    }
+    else if (anyData && typeof anyData === "object" && anyData.advisories) {
+        // Legacy npm audit format with `advisories`.
+        const advisories = anyData.advisories;
+        for (const adv of Object.values(advisories)) {
+            const severity = adv.severity;
+            const moduleName = adv.module_name;
+            if (!severity || !moduleName || !severityAtLeast(severity, minSeverity))
+                continue;
+            counts[severity] += 1;
+            pkgCounts.set(moduleName, (pkgCounts.get(moduleName) ?? 0) + 1);
+        }
+    }
+    else if (anyData && anyData.metadata && anyData.metadata.vulnerabilities) {
+        // Fallback: just lift counts from metadata if available.
+        const metaCounts = anyData.metadata.vulnerabilities;
+        for (const sev of severityOrder) {
+            const value = metaCounts[sev];
+            if (typeof value === "number" && severityAtLeast(sev, minSeverity)) {
+                counts[sev] += value;
+            }
+        }
+    }
+    const impactedPackages = Array.from(pkgCounts.entries())
+        .map(([name, count]) => ({ name, count }))
+        .sort((a, b) => b.count - a.count)
+        .slice(0, 5);
+    return { counts, impactedPackages };
+}
+export function printAuditSummary(summary) {
+    const { counts, impactedPackages } = summary;
+    logInfo("Vulnerability summary:");
+    logInfo(`  low: ${counts.low}, moderate: ${counts.moderate}, high: ${counts.high}, critical: ${counts.critical}`);
+    if (impactedPackages.length > 0) {
+        logInfo("Top affected packages:");
+        for (const pkg of impactedPackages) {
+            logInfo(`  ${pkg.name}: ${pkg.count} issue(s)`);
+        }
+    }
+    else {
+        logInfo("No vulnerable packages found at or above the selected severity.");
+    }
+    logInfo("What to do next:");
+    logInfo("  - Run `npm audit fix` to apply safe automatic fixes.");
+    logInfo("  - For remaining issues, review advisories and consider upgrading major versions or replacing packages.");
+    logInfo("  - If you cannot upgrade immediately, consider using overrides/resolutions with care and track them for cleanup.");
+}
+// Temporary placeholder to keep the existing `fix` command wired up.
+// This can later be replaced with a real remediation flow.
+export async function runFix() {
+    logInfo("Running depfix-ai fix (not implemented yet).");
+}

package/dist/lib/config/store.d.ts

@@ -0,0 +1,6 @@
+export interface Config {
+    dryRun: boolean;
+}
+export declare function getConfig(): Config;
+export declare function setConfig(next: Partial<Config>): void;
+//# sourceMappingURL=store.d.ts.map

package/dist/lib/config/store.js

@@ -0,0 +1,9 @@
+let currentConfig = {
+    dryRun: false,
+};
+export function getConfig() {
+    return currentConfig;
+}
+export function setConfig(next) {
+    currentConfig = { ...currentConfig, ...next };
+}

package/dist/lib/env/ai.d.ts

@@ -0,0 +1,20 @@
+export type AIEnvDoc = {
+    key: string;
+    description: string;
+    where_to_get: string;
+    example_value: string;
+    is_secret: boolean;
+};
+export type AIGenerateOptions = {
+    apiKey: string;
+    model: string;
+    projectHint?: string;
+    contexts: Record<string, {
+        file: string;
+        line: number;
+        snippet: string;
+    }[]>;
+    keys: string[];
+};
+export declare function generateEnvDocsWithOpenAI(opts: AIGenerateOptions): Promise<AIEnvDoc[]>;
+//# sourceMappingURL=ai.d.ts.map

package/dist/lib/env/ai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai.d.ts","sourceRoot":"","sources":["../../../src/lib/env/ai.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC,CAAC;IAC5E,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAoGF,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC,QAAQ,EAAE,CAAC,CAiDrB"}

package/dist/lib/env/ai.js

@@ -0,0 +1,139 @@
+const JSON_SCHEMA = {
+    name: "env_docs",
+    strict: true,
+    schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            items: {
+                type: "array",
+                items: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        key: { type: "string" },
+                        description: { type: "string" },
+                        where_to_get: { type: "string" },
+                        example_value: { type: "string" },
+                        is_secret: { type: "boolean" },
+                    },
+                    required: [
+                        "key",
+                        "description",
+                        "where_to_get",
+                        "example_value",
+                        "is_secret",
+                    ],
+                },
+            },
+        },
+        required: ["items"],
+    },
+};
+function buildInput(opts) {
+    const lines = opts.keys.map((k) => {
+        const ctx = opts.contexts[k]?.[0];
+        const seenAt = ctx ? `${ctx.file}:${ctx.line}` : "unknown";
+        const snippet = ctx ? ctx.snippet : "";
+        return `- ${k}\n  seen_at: ${seenAt}\n  snippet: ${snippet}`;
+    });
+    const system = [
+        "You generate documentation for environment variables.",
+        "Return ONLY JSON that matches the provided JSON Schema.",
+        "Do not include markdown or extra text.",
+        "Never output real secrets. Use safe placeholders.",
+        "Keep descriptions short and practical.",
+        "where_to_get must be actionable (dashboard, secret manager, CI, local service, etc.).",
+    ].join(" ");
+    const user = [
+        opts.projectHint ? `Project hint: ${opts.projectHint}` : "",
+        "Variables:",
+        ...lines,
+    ]
+        .filter(Boolean)
+        .join("\n");
+    return [
+        { role: "system", content: system },
+        { role: "user", content: user },
+    ];
+}
+function extractTextFromResponses(data) {
+    if (typeof data?.output_text === "string") {
+        const t = data.output_text.trim();
+        if (t)
+            return t;
+    }
+    const out = data?.output;
+    if (Array.isArray(out)) {
+        for (const item of out) {
+            const content = item?.content;
+            if (!Array.isArray(content))
+                continue;
+            for (const c of content) {
+                const text = c?.text;
+                if (typeof text === "string" && text.trim())
+                    return text;
+            }
+        }
+    }
+    return "";
+}
+function tryParseJsonLoose(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        const m = raw.match(/\{[\s\S]*\}/);
+        if (!m)
+            return null;
+        try {
+            return JSON.parse(m[0]);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+export async function generateEnvDocsWithOpenAI(opts) {
+    const input = buildInput(opts);
+    const res = await fetch("https://api.openai.com/v1/responses", {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${opts.apiKey}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            model: opts.model,
+            input,
+            text: {
+                format: {
+                    type: "json_schema",
+                    ...JSON_SCHEMA,
+                },
+            },
+        }),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`OpenAI request failed (${res.status}): ${text}`);
+    }
+    const data = await res.json();
+    const raw = extractTextFromResponses(data).trim();
+    const parsed = tryParseJsonLoose(raw);
+    if (!parsed) {
+        throw new Error("AI output was not valid JSON. Try again, or use a different model.");
+    }
+    const items = Array.isArray(parsed?.items) ? parsed.items : [];
+    return items
+        .map((x) => {
+        const o = x;
+        return {
+            key: String(o?.key ?? ""),
+            description: String(o?.description ?? ""),
+            where_to_get: String(o?.where_to_get ?? ""),
+            example_value: String(o?.example_value ?? ""),
+            is_secret: Boolean(o?.is_secret),
+        };
+    })
+        .filter((x) => x.key.length > 0);
+}

package/dist/lib/env/render.d.ts

@@ -0,0 +1,4 @@
+import type { AIEnvDoc } from "./ai.js";
+import type { EnvScanResult } from "./scan.js";
+export declare function renderEnv(result: EnvScanResult, aiDocs?: AIEnvDoc[]): string;
+//# sourceMappingURL=render.d.ts.map

package/dist/lib/env/render.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../../src/lib/env/render.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAgB1C,wBAAgB,SAAS,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CA6BvD"}
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../../src/lib/env/render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAgB/C,wBAAgB,SAAS,CACvB,MAAM,EAAE,aAAa,EACrB,MAAM,CAAC,EAAE,QAAQ,EAAE,GAClB,MAAM,CA6CR"}

package/dist/lib/env/render.js

@@ -0,0 +1,50 @@
+const GROUPS = [
+    { prefix: "DB_", heading: "Database" },
+    { prefix: "REDIS_", heading: "Redis" },
+    { prefix: "AWS_", heading: "AWS" },
+    { prefix: "SMTP_", heading: "SMTP" },
+    { prefix: "NEXT_PUBLIC_", heading: "Next.js public env" },
+    { prefix: "VITE_", heading: "Vite env" },
+];
+export function renderEnv(result, aiDocs) {
+    const remaining = new Set(result.keys);
+    const groups = [];
+    for (const { prefix, heading } of GROUPS) {
+        const keys = result.keys.filter((k) => k.startsWith(prefix));
+        if (keys.length === 0)
+            continue;
+        keys.forEach((k) => remaining.delete(k));
+        groups.push({ heading, keys });
+    }
+    if (remaining.size > 0) {
+        groups.push({
+            heading: "Other",
+            keys: Array.from(remaining).sort(),
+        });
+    }
+    const byKey = aiDocs?.length
+        ? new Map(aiDocs.map((d) => [d.key, d]))
+        : null;
+    const lines = [];
+    for (const group of groups) {
+        lines.push(`# ${group.heading}`);
+        for (const key of group.keys) {
+            const d = byKey?.get(key);
+            if (d) {
+                const secretNote = d.is_secret
+                    ? "Secret value. Do not commit."
+                    : "Non-secret value (verify before committing).";
+                lines.push(`# ${d.key}`);
+                lines.push(`# ${d.description}`);
+                lines.push(`# Where to get it: ${d.where_to_get}`);
+                lines.push(`# ${secretNote}`);
+                lines.push(`${d.key}=${d.example_value ?? ""}`);
+            }
+            else {
+                lines.push(`${key}=`);
+            }
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trimEnd() + (lines.length ? "\n" : "");
+}

package/dist/lib/env/scan.d.ts

@@ -0,0 +1,14 @@
+export interface EnvScanResult {
+    keys: string[];
+}
+export interface KeyContext {
+    file: string;
+    line: number;
+    snippet: string;
+}
+export interface EnvScanWithContextResult extends EnvScanResult {
+    contexts: Record<string, KeyContext[]>;
+}
+export declare function scanEnv(cwd?: string): Promise<EnvScanResult>;
+export declare function scanEnvWithContext(cwd?: string, maxContextPerKey?: number): Promise<EnvScanWithContextResult>;
+//# sourceMappingURL=scan.d.ts.map

package/dist/lib/env/scan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../../src/lib/env/scan.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAcD,wBAAsB,OAAO,CAAC,GAAG,SAAgB,GAAG,OAAO,CAAC,aAAa,CAAC,CA6BzE"}
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../../src/lib/env/scan.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,wBAAyB,SAAQ,aAAa;IAC7D,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;CACxC;AA6BD,wBAAsB,OAAO,CAAC,GAAG,SAAgB,GAAG,OAAO,CAAC,aAAa,CAAC,CAGzE;AAED,wBAAsB,kBAAkB,CACtC,GAAG,SAAgB,EACnB,gBAAgB,SAAI,GACnB,OAAO,CAAC,wBAAwB,CAAC,CAqDnC"}

package/dist/lib/env/scan.js

@@ -0,0 +1,83 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import fg from "fast-glob";
+const INCLUDE_GLOBS = [
+    "src/**/*.{js,jsx,ts,tsx,mjs,cjs}",
+    "app/**/*.{js,jsx,ts,tsx,mjs,cjs}",
+    "server/**/*.{js,jsx,ts,tsx,mjs,cjs}",
+    "pages/**/*.{js,jsx,ts,tsx,mjs,cjs}",
+];
+const EXCLUDE_GLOBS = ["**/node_modules/**", "**/dist/**", "**/.next/**", "**/build/**", "**/coverage/**"];
+const ENV_KEY_STRICT = /^[A-Z][A-Z0-9_]*$/;
+// Patterns: [RegExp, group index for key]
+const CODE_PATTERNS = [
+    [/\bprocess(?:\?\.|\.)env(?:\?\.|\.)([A-Za-z_][A-Za-z0-9_]*)\b/g, 1],
+    [/\bprocess(?:\?\.|\.)env\[\s*["']([A-Za-z_][A-Za-z0-9_]*)["']\s*\]/g, 1],
+    [/\bimport\.meta\.env\.([A-Za-z_][A-Za-z0-9_]*)\b/g, 1],
+    [/\bDeno\.env\.get\(\s*["']([A-Za-z_][A-Za-z0-9_]*)["']\s*\)/g, 1],
+    [/\bBun\.env\.([A-Za-z_][A-Za-z0-9_]*)\b/g, 1],
+];
+const PROCESS_ENV_REGEX = /process\.env\.([A-Z0-9_]+)/g;
+const IMPORT_META_ENV_REGEX = /import\.meta\.env\.([A-Z0-9_]+)/g;
+function keyOk(k) {
+    return ENV_KEY_STRICT.test(k);
+}
+export async function scanEnv(cwd = process.cwd()) {
+    const withCtx = await scanEnvWithContext(cwd, 0);
+    return { keys: withCtx.keys };
+}
+export async function scanEnvWithContext(cwd = process.cwd(), maxContextPerKey = 2) {
+    const files = await fg(INCLUDE_GLOBS, {
+        cwd,
+        ignore: EXCLUDE_GLOBS,
+        absolute: true,
+    });
+    const keys = new Set();
+    const contexts = {};
+    function addCtx(key, relFile, line, snippet) {
+        if (!keyOk(key))
+            return;
+        keys.add(key);
+        if (maxContextPerKey <= 0)
+            return;
+        if (!contexts[key])
+            contexts[key] = [];
+        if (contexts[key].length >= maxContextPerKey)
+            return;
+        contexts[key].push({
+            file: relFile,
+            line,
+            snippet: snippet.trim().slice(0, 220),
+        });
+    }
+    for (const absPath of files) {
+        let content;
+        try {
+            content = await fs.readFile(absPath, "utf8");
+        }
+        catch {
+            continue;
+        }
+        const relFile = path.relative(cwd, absPath).replace(/\\/g, "/");
+        const lines = content.split(/\r?\n/);
+        for (let i = 0; i < lines.length; i++) {
+            const ln = lines[i];
+            if (ln.trim().startsWith("//") || ln.trim().startsWith("#"))
+                continue;
+            for (const [re, group] of CODE_PATTERNS) {
+                re.lastIndex = 0;
+                let match;
+                while ((match = re.exec(ln)) !== null) {
+                    const k = match[group];
+                    if (!keyOk(k))
+                        continue;
+                    addCtx(k, relFile, i + 1, ln);
+                }
+            }
+        }
+    }
+    return {
+        keys: Array.from(keys).sort(),
+        contexts,
+    };
+}

package/dist/lib/env/write.d.ts

@@ -0,0 +1,11 @@
+export interface EnvGenerateFlags {
+    out: string;
+    create: boolean;
+    force: boolean;
+    check: boolean;
+    ai: boolean;
+    model: string;
+    apiKey: string;
+}
+export declare function runEnvGenerate(opts?: Partial<EnvGenerateFlags>): Promise<void>;
+//# sourceMappingURL=write.d.ts.map

package/dist/lib/env/write.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../../src/lib/env/write.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;CAChB;AAgCD,wBAAsB,cAAc,CAAC,IAAI,GAAE,OAAO,CAAC,gBAAgB,CAAM,iBA8CxE"}
+{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../../src/lib/env/write.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAmCD,wBAAsB,cAAc,CAAC,IAAI,GAAE,OAAO,CAAC,gBAAgB,CAAM,iBA6ExE"}

package/dist/lib/env/write.js

@@ -0,0 +1,108 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { generateEnvDocsWithOpenAI } from "./ai.js";
+import { renderEnv } from "./render.js";
+import { scanEnv, scanEnvWithContext } from "./scan.js";
+import { logInfo, logError } from "../ui/log.js";
+const defaultEnvFlags = {
+    out: ".env.example",
+    create: false,
+    force: false,
+    check: false,
+    ai: false,
+    model: "gpt-4o-mini",
+    apiKey: "",
+};
+async function fileExists(p) {
+    try {
+        await fs.stat(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function parseEnvKeysFromExample(content) {
+    const keys = new Set();
+    const lines = content.split(/\r?\n/);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const eqIndex = trimmed.indexOf("=");
+        if (eqIndex <= 0)
+            continue;
+        const key = trimmed.slice(0, eqIndex).trim();
+        if (key)
+            keys.add(key);
+    }
+    return keys;
+}
+export async function runEnvGenerate(opts = {}) {
+    const flags = { ...defaultEnvFlags, ...opts };
+    const cwd = process.cwd();
+    const outPath = path.resolve(cwd, flags.out);
+    const envPath = path.resolve(cwd, ".env");
+    const scanResult = flags.ai
+        ? await scanEnvWithContext(cwd, 2)
+        : await scanEnv(cwd);
+    if (flags.check) {
+        if (!(await fileExists(outPath))) {
+            logError(`${flags.out} does not exist. Run 'depfix-ai env generate' to create it.`);
+            process.exitCode = 1;
+            return;
+        }
+        const existing = await fs.readFile(outPath, "utf8");
+        const existingKeys = parseEnvKeysFromExample(existing);
+        const missing = scanResult.keys.filter((k) => !existingKeys.has(k));
+        if (missing.length > 0) {
+            logError(`${flags.out} is missing the following environment variables: ${missing.join(", ")}`);
+            process.exitCode = 1;
+            return;
+        }
+        logInfo(`${flags.out} contains all required environment variables.`);
+        return;
+    }
+    let aiDocs;
+    if (flags.ai && scanResult.keys.length > 0) {
+        const apiKey = flags.apiKey || process.env.OPENAI_API_KEY?.trim();
+        if (!apiKey) {
+            logError("AI mode requires OPENAI_API_KEY or --api-key.");
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            logInfo("Generating descriptions with AI…");
+            const contexts = "contexts" in scanResult && scanResult.contexts
+                ? scanResult.contexts
+                : Object.create(null);
+            aiDocs = await generateEnvDocsWithOpenAI({
+                apiKey,
+                model: flags.model,
+                projectHint: "Practical guidance for developers setting env vars.",
+                contexts,
+                keys: scanResult.keys,
+            });
+        }
+        catch (e) {
+            logError(e?.message ?? String(e));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    // Always (re)write the template example file.
+    const exampleContent = renderEnv(scanResult, aiDocs);
+    await fs.writeFile(outPath, exampleContent, "utf8");
+    logInfo(`Wrote environment template to ${outPath}`);
+    if (flags.create) {
+        const envExists = await fileExists(envPath);
+        if (envExists && !flags.force) {
+            logInfo(`.env already exists; not overwriting. Use --force to overwrite.`);
+        }
+        else {
+            const envContent = scanResult.keys.map((k) => `${k}=`).join("\n") + "\n";
+            await fs.writeFile(envPath, envContent, "utf8");
+            logInfo(`Wrote ${envExists ? "updated" : "new"} .env file to ${envPath}`);
+        }
+    }
+}

package/dist/lib/git/commit.d.ts

@@ -0,0 +1,2 @@
+export declare function gitCommitAll(message: string, cwd?: string): Promise<void>;
+//# sourceMappingURL=commit.d.ts.map

package/dist/lib/git/commit.js

@@ -0,0 +1,5 @@
+import { execa } from "execa";
+export async function gitCommitAll(message, cwd = process.cwd()) {
+    await execa("git", ["add", "-A"], { cwd, stdio: "inherit" });
+    await execa("git", ["commit", "-m", message], { cwd, stdio: "inherit" });
+}

package/dist/lib/git/diff.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Return git diff output for the given paths (e.g. package.json, package-lock.json).
+ * Used for fix preview before applying changes.
+ */
+export declare function gitDiff(paths?: string[], cwd?: string): Promise<string>;
+//# sourceMappingURL=diff.d.ts.map

package/dist/lib/git/diff.js

@@ -0,0 +1,12 @@
+import { execa } from "execa";
+/**
+ * Return git diff output for the given paths (e.g. package.json, package-lock.json).
+ * Used for fix preview before applying changes.
+ */
+export async function gitDiff(paths = [], cwd = process.cwd()) {
+    const args = ["diff", "--no-color"];
+    if (paths.length > 0)
+        args.push("--", ...paths);
+    const { stdout } = await execa("git", args, { cwd });
+    return stdout;
+}

package/dist/lib/git/stash.d.ts

@@ -0,0 +1,2 @@
+export declare function gitStashSave(message?: string, cwd?: string): Promise<void>;
+//# sourceMappingURL=stash.d.ts.map

package/dist/lib/git/stash.js

@@ -0,0 +1,4 @@
+import { execa } from "execa";
+export async function gitStashSave(message = "depfix-ai backup", cwd = process.cwd()) {
+    await execa("git", ["stash", "push", "-m", message], { cwd, stdio: "inherit" });
+}

package/dist/lib/git/status.d.ts

@@ -0,0 +1,2 @@
+export declare function gitStatusShort(cwd?: string): Promise<string>;
+//# sourceMappingURL=status.d.ts.map

package/dist/lib/git/status.js

@@ -0,0 +1,5 @@
+import { execa } from "execa";
+export async function gitStatusShort(cwd = process.cwd()) {
+    const { stdout } = await execa("git", ["status", "--short"], { cwd });
+    return stdout;
+}

package/dist/lib/pm/detect.d.ts

@@ -0,0 +1,3 @@
+import { PackageManager } from "./types.js";
+export declare function detectPackageManager(cwd?: string): PackageManager;
+//# sourceMappingURL=detect.d.ts.map

package/dist/lib/pm/detect.js

@@ -0,0 +1,19 @@
+import fs from "node:fs";
+import path from "node:path";
+export function detectPackageManager(cwd = process.cwd()) {
+    // Priority:
+    // 1. pnpm (pnpm-lock.yaml)
+    // 2. yarn (yarn.lock)
+    // 3. npm (package-lock.json)
+    // 4. bun (bun.lockb)
+    if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (fs.existsSync(path.join(cwd, "yarn.lock")))
+        return "yarn";
+    if (fs.existsSync(path.join(cwd, "package-lock.json")))
+        return "npm";
+    if (fs.existsSync(path.join(cwd, "bun.lockb")))
+        return "bun";
+    // Fallback to npm if no known lockfile is present.
+    return "npm";
+}

package/dist/lib/pm/run.d.ts

@@ -0,0 +1,3 @@
+import { PackageManager, RunOptions, RunResult } from "./types.js";
+export declare function runPmCommand(pm: PackageManager, args: string[], options?: RunOptions): Promise<RunResult>;
+//# sourceMappingURL=run.d.ts.map

package/dist/lib/pm/run.js

@@ -0,0 +1,10 @@
+import { execa } from "execa";
+export async function runPmCommand(pm, args, options = {}) {
+    const { stdout, stderr, exitCode } = await execa(pm, args, {
+        cwd: options.cwd,
+        stdio: options.stdio ?? "pipe",
+        // Never throw on non‑zero exit codes; always resolve with the result.
+        reject: false,
+    });
+    return { stdout, stderr, exitCode };
+}

package/dist/lib/pm/types.d.ts

@@ -0,0 +1,11 @@
+export type PackageManager = "npm" | "yarn" | "pnpm" | "bun";
+export interface RunOptions {
+    cwd?: string;
+    stdio?: "inherit" | "pipe";
+}
+export interface RunResult {
+    stdout?: string;
+    stderr?: string;
+    exitCode?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/pm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/safety/backup.d.ts

@@ -0,0 +1,7 @@
+export interface OnboardFlags {
+    skipInstall: boolean;
+    skipEnv: boolean;
+    skipTest: boolean;
+}
+export declare function runOnboard(opts?: Partial<OnboardFlags>): Promise<void>;
+//# sourceMappingURL=backup.d.ts.map

package/dist/lib/safety/backup.js

@@ -0,0 +1,16 @@
+import { gitStashSave } from "../git/stash.js";
+import { logInfo } from "../ui/log.js";
+export async function runOnboard(opts = {}) {
+    const skipInstall = opts.skipInstall ?? false;
+    const skipEnv = opts.skipEnv ?? false;
+    const skipTest = opts.skipTest ?? false;
+    logInfo("Onboarding project with depfix-ai (minimal stub).");
+    if (skipInstall)
+        logInfo("Will skip install (--skip-install).");
+    if (skipEnv)
+        logInfo("Will skip env generate (--skip-env).");
+    if (skipTest)
+        logInfo("Will skip tests (--skip-test).");
+    await gitStashSave("depfix-ai onboarding backup");
+    logInfo("Created git stash as a safety backup.");
+}

package/dist/lib/safety/dryRun.d.ts

@@ -0,0 +1,3 @@
+export declare function startDryRun(): void;
+export declare function endDryRun(): void;
+//# sourceMappingURL=dryRun.d.ts.map

package/dist/lib/safety/dryRun.js

@@ -0,0 +1,7 @@
+import { logInfo } from "../ui/log.js";
+export function startDryRun() {
+    logInfo("Starting dry run (no changes will be written).");
+}
+export function endDryRun() {
+    logInfo("Finished dry run.");
+}

package/dist/lib/ui/log.d.ts

@@ -0,0 +1,3 @@
+export declare function logInfo(message: string, ...rest: unknown[]): void;
+export declare function logError(message: string, ...rest: unknown[]): void;
+//# sourceMappingURL=log.d.ts.map

package/dist/lib/ui/log.js

@@ -0,0 +1,7 @@
+import chalk from "chalk";
+export function logInfo(message, ...rest) {
+    console.log(chalk.cyan("[depfix-ai]"), message, ...rest);
+}
+export function logError(message, ...rest) {
+    console.error(chalk.red("[depfix-ai]"), message, ...rest);
+}

package/dist/lib/ui/spinner.d.ts

@@ -0,0 +1,2 @@
+export declare function createSpinner(text: string): import("ora").Ora;
+//# sourceMappingURL=spinner.d.ts.map

package/dist/lib/ui/spinner.js

@@ -0,0 +1,4 @@
+import ora from "ora";
+export function createSpinner(text) {
+    return ora({ text });
+}

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "depfix-ai",
-  "version": "0.1.2",
+  "version": "0.2.2",
   "type": "module",
   "license": "MIT",
   "engines": {
     "node": ">=18"
   },
+  "packageManager": "pnpm@9.15.0",
   "scripts": {
     "build": "tsc -b",
     "test": "vitest run",
@@ -20,7 +21,11 @@
     "dist/**"
   ],
   "bin": {
-    "depfix-ai": "./bin/run.js"
+    "depfix-ai": "bin/run.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hesxo/depfix-ai.git"
   },
   "oclif": {
     "commands": "./dist/commands",
@@ -29,6 +34,7 @@
   "dependencies": {
     "@oclif/core": "^4.0.0",
     "chalk": "^5.6.2",
+    "depfix-ai": "^0.1.2",
     "execa": "^9.6.1",
     "fast-glob": "^3.3.3",
     "ora": "^9.3.0",