@paytmsupport/paytm-jarvis 1.0.0

package/dist/commands/log.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logCommand = logCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const context_1 = require("../core/context");
+const git_1 = require("../core/git");
+async function logCommand(options) {
+    if (!(await (0, context_1.isInitialized)())) {
+        console.log(chalk_1.default.red("✗ DevContext not initialized. Run `jarvis init` first."));
+        return;
+    }
+    try {
+        const count = parseInt(options?.count || "10", 10);
+        if (options?.all) {
+            const sessions = await (0, context_1.loadAllSessions)();
+            if (sessions.length === 0) {
+                console.log(chalk_1.default.yellow("No context entries found."));
+                return;
+            }
+            console.log(chalk_1.default.bold("\nAll branches:\n"));
+            sessions.slice(0, count).forEach((s) => {
+                const date = new Date(s.timestamp).toLocaleString();
+                console.log(`  ${chalk_1.default.gray(`[${date}]`)} ${chalk_1.default.cyan(s.branch)} ${s.task}`);
+            });
+        }
+        else {
+            const branch = await (0, git_1.getCurrentBranch)();
+            const entries = await (0, context_1.loadBranchContext)(branch);
+            if (entries.length === 0) {
+                console.log(chalk_1.default.yellow(`No context for branch: ${branch}`));
+                return;
+            }
+            console.log(chalk_1.default.bold(`\nBranch: ${branch}\n`));
+            entries
+                .slice(-count)
+                .reverse()
+                .forEach((e) => {
+                const date = new Date(e.timestamp).toLocaleString();
+                console.log(`  ${chalk_1.default.gray(`[${date}]`)} ${e.task}`);
+                if (e.currentState) {
+                    console.log(`    ${chalk_1.default.gray("└─")} ${e.currentState}`);
+                }
+            });
+        }
+        console.log();
+    }
+    catch (err) {
+        console.log(chalk_1.default.red(`✗ Error: ${err.message}`));
+    }
+}

package/dist/commands/resume.d.ts

@@ -0,0 +1,4 @@
+export declare function resumeCommand(options?: {
+    branch?: string;
+    stdout?: boolean;
+}): Promise<void>;

package/dist/commands/resume.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resumeCommand = resumeCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const context_1 = require("../core/context");
+const git_1 = require("../core/git");
+const prompt_1 = require("../core/prompt");
+const clipboard_1 = require("../utils/clipboard");
+async function resumeCommand(options) {
+    if (!(await (0, context_1.isInitialized)())) {
+        console.log(chalk_1.default.red("✗ DevContext not initialized. Run `jarvis init` first."));
+        return;
+    }
+    try {
+        const branch = options?.branch || (await (0, git_1.getCurrentBranch)());
+        const entries = await (0, context_1.loadBranchContext)(branch);
+        if (entries.length === 0) {
+            console.log(chalk_1.default.yellow(`⚠ No context found for branch: ${branch}`));
+            console.log(chalk_1.default.gray("  Run `jarvis save` to capture context first."));
+            return;
+        }
+        const prompt = (0, prompt_1.generatePrompt)(entries);
+        if (options?.stdout) {
+            console.log(prompt);
+        }
+        else {
+            const copied = await (0, clipboard_1.copyToClipboard)(prompt);
+            if (copied) {
+                console.log(chalk_1.default.green("📋 Context copied to clipboard!"));
+                console.log(chalk_1.default.gray(`  Branch: ${branch} | ${entries.length} sessions | Paste into any AI tool`));
+            }
+            else {
+                // Fallback: print to stdout if clipboard failed
+                console.log(prompt);
+            }
+        }
+    }
+    catch (err) {
+        console.log(chalk_1.default.red(`✗ Error: ${err.message}`));
+    }
+}

package/dist/commands/save.d.ts

@@ -0,0 +1,13 @@
+interface SaveOptions {
+    goal?: string;
+    approaches?: string;
+    decisions?: string;
+    state?: string;
+    nextSteps?: string;
+    blockers?: string;
+    assignee?: string;
+    handoffNote?: string;
+    auto?: boolean;
+}
+export declare function saveCommand(message?: string, options?: SaveOptions): Promise<void>;
+export {};

package/dist/commands/save.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveCommand = saveCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const uuid_1 = require("uuid");
+const context_1 = require("../core/context");
+const git_1 = require("../core/git");
+const parser_1 = require("../core/parser");
+async function saveCommand(message, options) {
+    if (!(await (0, context_1.isInitialized)())) {
+        console.log(chalk_1.default.red("✗ DevContext not initialized. Run `jarvis init` first."));
+        return;
+    }
+    try {
+        const [branch, repo, filesChanged, filesStaged, recentCommits, author] = await Promise.all([
+            (0, git_1.getCurrentBranch)(),
+            (0, git_1.getRepoName)(),
+            (0, git_1.getChangedFiles)(),
+            (0, git_1.getStagedFiles)(),
+            (0, git_1.getRecentCommits)(),
+            (0, git_1.getAuthor)(),
+        ]);
+        let task = message || "";
+        let approaches = [];
+        let decisions = [];
+        let currentState = "";
+        let nextSteps = [];
+        let blockers = [];
+        // Check if structured flags were provided (AI agent mode)
+        const hasStructuredInput = options?.approaches || options?.decisions || options?.state || options?.nextSteps;
+        if (options?.auto) {
+            // Auto-extract mode — read from editor session data
+            console.log(chalk_1.default.gray("  Scanning editor sessions for context..."));
+            const cwd = process.cwd();
+            const extracted = await (0, parser_1.extractFromEditorSessions)(cwd);
+            if (extracted) {
+                task = message || extracted.task;
+                approaches = extracted.approaches;
+                decisions = extracted.decisions;
+                currentState = extracted.currentState;
+                nextSteps = extracted.nextSteps;
+                blockers = extracted.blockers;
+                console.log(chalk_1.default.gray(`  Found context from: ${extracted.source}`));
+            }
+            else {
+                console.log(chalk_1.default.yellow("⚠ No editor session data found. Using message only."));
+                task = message || "Session (auto-extract found nothing)";
+                currentState = message || "";
+            }
+        }
+        else if (hasStructuredInput && message) {
+            // Programmatic mode — AI agent is passing structured context
+            task = message;
+            approaches = options?.approaches
+                ? options.approaches.split(";;").map((s) => s.trim()).filter(Boolean)
+                : [];
+            decisions = options?.decisions
+                ? options.decisions.split(";;").map((s) => s.trim()).filter(Boolean)
+                : [];
+            currentState = options?.state || message;
+            nextSteps = options?.nextSteps
+                ? options.nextSteps.split(";;").map((s) => s.trim()).filter(Boolean)
+                : [];
+            blockers = options?.blockers
+                ? options.blockers.split(";;").map((s) => s.trim()).filter(Boolean)
+                : [];
+        }
+        else if (!message) {
+            // Interactive mode
+            const answers = await inquirer_1.default.prompt([
+                {
+                    type: "input",
+                    name: "task",
+                    message: "What were you working on?",
+                    validate: (input) => input.length > 0 || "Task description is required",
+                },
+                {
+                    type: "input",
+                    name: "approaches",
+                    message: "What approaches did you try? (comma-separated, or skip)",
+                    default: "",
+                },
+                {
+                    type: "input",
+                    name: "decisions",
+                    message: "Key decisions made? (comma-separated, or skip)",
+                    default: "",
+                },
+                {
+                    type: "input",
+                    name: "currentState",
+                    message: "Where did you leave off?",
+                    validate: (input) => input.length > 0 || "Current state is required",
+                },
+                {
+                    type: "input",
+                    name: "nextSteps",
+                    message: "What comes next? (comma-separated, or skip)",
+                    default: "",
+                },
+                {
+                    type: "input",
+                    name: "blockers",
+                    message: "Any blockers? (comma-separated, or skip)",
+                    default: "",
+                },
+            ]);
+            task = answers.task;
+            approaches = answers.approaches
+                ? answers.approaches.split(",").map((s) => s.trim()).filter(Boolean)
+                : [];
+            decisions = answers.decisions
+                ? answers.decisions.split(",").map((s) => s.trim()).filter(Boolean)
+                : [];
+            currentState = answers.currentState;
+            nextSteps = answers.nextSteps
+                ? answers.nextSteps.split(",").map((s) => s.trim()).filter(Boolean)
+                : [];
+            blockers = answers.blockers
+                ? answers.blockers.split(",").map((s) => s.trim()).filter(Boolean)
+                : [];
+        }
+        else {
+            // Simple message mode
+            currentState = message;
+        }
+        const entry = {
+            id: (0, uuid_1.v4)(),
+            timestamp: new Date().toISOString(),
+            branch,
+            repo,
+            author,
+            task,
+            goal: options?.goal,
+            approaches,
+            decisions,
+            currentState,
+            nextSteps,
+            blockers: blockers.length > 0 ? blockers : undefined,
+            filesChanged,
+            filesStaged,
+            recentCommits,
+            assignee: options?.assignee,
+            handoffNote: options?.handoffNote,
+        };
+        const savedTo = await (0, context_1.saveContext)(entry);
+        console.log(chalk_1.default.green(`✓ Context saved for branch: ${chalk_1.default.bold(branch)}`));
+        console.log(chalk_1.default.gray(`  ${filesChanged.length} files changed, ${recentCommits.length} recent commits captured`));
+        if (approaches.length > 0) {
+            console.log(chalk_1.default.gray(`  ${approaches.length} approaches, ${decisions.length} decisions recorded`));
+        }
+    }
+    catch (err) {
+        console.log(chalk_1.default.red(`✗ Error: ${err.message}`));
+    }
+}

package/dist/commands/share.d.ts

@@ -0,0 +1,3 @@
+export declare function shareCommand(options?: {
+    stop?: boolean;
+}): Promise<void>;

package/dist/commands/share.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shareCommand = shareCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const simple_git_1 = __importDefault(require("simple-git"));
+const git_1 = require("../core/git");
+const git = (0, simple_git_1.default)();
+async function shareCommand(options) {
+    try {
+        const root = await (0, git_1.getRepoRoot)();
+        const gitignorePath = path_1.default.join(root, ".gitignore");
+        const devctxDir = path_1.default.join(root, ".jarvis");
+        if (!fs_1.default.existsSync(devctxDir)) {
+            console.log(chalk_1.default.red("✗ DevContext not initialized. Run `jarvis init` first."));
+            return;
+        }
+        if (options?.stop) {
+            // Add .jarvis/ back to .gitignore
+            const gitignoreContent = fs_1.default.existsSync(gitignorePath)
+                ? fs_1.default.readFileSync(gitignorePath, "utf-8")
+                : "";
+            if (!gitignoreContent.includes(".jarvis/")) {
+                fs_1.default.appendFileSync(gitignorePath, "\n.jarvis/\n");
+            }
+            console.log(chalk_1.default.green("✓ Stopped sharing DevContext"));
+            console.log(chalk_1.default.gray("  .jarvis/ added back to .gitignore"));
+            console.log(chalk_1.default.gray("  Note: Existing .jarvis/ files remain in git history."));
+            return;
+        }
+        // Remove .jarvis/ from .gitignore
+        if (fs_1.default.existsSync(gitignorePath)) {
+            let content = fs_1.default.readFileSync(gitignorePath, "utf-8");
+            content = content
+                .split("\n")
+                .filter((line) => line.trim() !== ".jarvis/" &&
+                line.trim() !== ".jarvis" &&
+                line.trim() !== "# DevContext - AI coding context")
+                .join("\n");
+            fs_1.default.writeFileSync(gitignorePath, content);
+        }
+        // Stage .jarvis/ and commit
+        await git.add([".jarvis/", ".gitignore"]);
+        await git.commit("chore: share DevContext with team");
+        console.log(chalk_1.default.green("✓ DevContext is now shared with your team!"));
+        console.log(chalk_1.default.gray("  .jarvis/ removed from .gitignore"));
+        console.log(chalk_1.default.gray("  Committed: \"chore: share DevContext with team\""));
+        console.log(chalk_1.default.gray("\n  Push to share: git push"));
+        console.log(chalk_1.default.gray("  Stop sharing: jarvis share --stop"));
+    }
+    catch (err) {
+        console.log(chalk_1.default.red(`✗ Error: ${err.message}`));
+    }
+}

package/dist/commands/suggest.d.ts

@@ -0,0 +1 @@
+export declare function suggestCommand(): Promise<void>;

package/dist/commands/suggest.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suggestCommand = suggestCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const context_1 = require("../core/context");
+const git_1 = require("../core/git");
+const ai_1 = require("../core/ai");
+async function suggestCommand() {
+    if (!(await (0, context_1.isInitialized)())) {
+        console.log(chalk_1.default.red("✗ DevContext not initialized. Run `jarvis init` first."));
+        return;
+    }
+    try {
+        const branch = await (0, git_1.getCurrentBranch)();
+        const entries = await (0, context_1.loadBranchContext)(branch);
+        const [filesChanged, recentCommits] = await Promise.all([
+            (0, git_1.getChangedFiles)(),
+            (0, git_1.getRecentCommits)(10),
+        ]);
+        if (entries.length === 0 && filesChanged.length === 0) {
+            console.log(chalk_1.default.yellow("⚠ No context or changes found. Nothing to analyze."));
+            return;
+        }
+        console.log(chalk_1.default.gray("  Analyzing codebase and context..."));
+        const latest = entries[entries.length - 1];
+        const contextSummary = latest
+            ? `Current task: ${latest.task}
+Current state: ${latest.currentState}
+Previous approaches: ${latest.approaches.join(", ") || "none"}
+Previous decisions: ${latest.decisions.join(", ") || "none"}
+Known blockers: ${latest.blockers?.join(", ") || "none"}
+Previous next steps: ${latest.nextSteps.join(", ") || "none"}`
+            : "No previous context available.";
+        const prompt = `You are a senior developer mentor. Based on the following project context, suggest concrete next steps.
+
+Branch: ${branch}
+
+${contextSummary}
+
+Recent commits:
+${recentCommits.map((c) => `- ${c}`).join("\n")}
+
+Currently changed files: ${filesChanged.join(", ") || "none"}
+
+Provide 3-5 specific, actionable next steps. For each step, briefly explain WHY it's important. Format as a numbered list.`;
+        const result = await (0, ai_1.callAI)([
+            {
+                role: "system",
+                content: "You are a helpful senior developer. Be concise and actionable.",
+            },
+            { role: "user", content: prompt },
+        ]);
+        if (result.error) {
+            console.log(chalk_1.default.red(`✗ ${result.error}`));
+            return;
+        }
+        console.log(chalk_1.default.bold.cyan("\n💡 Suggested Next Steps\n"));
+        console.log(result.content);
+        console.log();
+    }
+    catch (err) {
+        console.log(chalk_1.default.red(`✗ Error: ${err.message}`));
+    }
+}

package/dist/commands/summarize.d.ts

@@ -0,0 +1 @@
+export declare function summarizeCommand(): Promise<void>;

package/dist/commands/summarize.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeCommand = summarizeCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const uuid_1 = require("uuid");
+const context_1 = require("../core/context");
+const git_1 = require("../core/git");
+const ai_1 = require("../core/ai");
+const simple_git_1 = __importDefault(require("simple-git"));
+const git = (0, simple_git_1.default)();
+async function summarizeCommand() {
+    if (!(await (0, context_1.isInitialized)())) {
+        console.log(chalk_1.default.red("✗ DevContext not initialized. Run `jarvis init` first."));
+        return;
+    }
+    try {
+        console.log(chalk_1.default.gray("  Analyzing git changes..."));
+        const [branch, repo, filesChanged, filesStaged, recentCommits, author] = await Promise.all([
+            (0, git_1.getCurrentBranch)(),
+            (0, git_1.getRepoName)(),
+            (0, git_1.getChangedFiles)(),
+            (0, git_1.getStagedFiles)(),
+            (0, git_1.getRecentCommits)(10),
+            (0, git_1.getAuthor)(),
+        ]);
+        // Get git diff for context
+        let diffSummary = "";
+        try {
+            const diff = await git.diff(["--stat"]);
+            diffSummary = diff.slice(0, 2000); // cap at 2k chars
+        }
+        catch {
+            diffSummary = "No diff available";
+        }
+        const prompt = `You are a developer assistant. Based on the following git activity, generate a concise coding context summary.
+
+Repository: ${repo}
+Branch: ${branch}
+Author: ${author}
+
+Recent commits:
+${recentCommits.map((c) => `- ${c}`).join("\n")}
+
+Files changed: ${filesChanged.join(", ") || "none"}
+Files staged: ${filesStaged.join(", ") || "none"}
+
+Diff summary:
+${diffSummary}
+
+Generate a JSON response with:
+{
+  "task": "one-line description of what's being worked on",
+  "approaches": ["approach 1", "approach 2"],
+  "decisions": ["decision 1"],
+  "currentState": "where things currently stand",
+  "nextSteps": ["step 1", "step 2"]
+}
+
+Be concise. Only include approaches/decisions if they're clearly evident from the commits and changes.`;
+        console.log(chalk_1.default.gray("  Generating AI summary..."));
+        const result = await (0, ai_1.callAI)([
+            { role: "system", content: "You are a helpful developer assistant. Always respond with valid JSON." },
+            { role: "user", content: prompt },
+        ]);
+        if (result.error) {
+            console.log(chalk_1.default.red(`✗ ${result.error}`));
+            return;
+        }
+        // Parse AI response
+        let parsed;
+        try {
+            // Extract JSON from potential markdown code blocks
+            const jsonMatch = result.content.match(/```(?:json)?\s*([\s\S]*?)```/) ||
+                [null, result.content];
+            parsed = JSON.parse(jsonMatch[1].trim());
+        }
+        catch {
+            console.log(chalk_1.default.yellow("⚠ Could not parse AI response. Saving raw summary."));
+            parsed = {
+                task: result.content.slice(0, 200),
+                approaches: [],
+                decisions: [],
+                currentState: result.content,
+                nextSteps: [],
+            };
+        }
+        const entry = {
+            id: (0, uuid_1.v4)(),
+            timestamp: new Date().toISOString(),
+            branch,
+            repo,
+            author,
+            task: parsed.task || "AI-generated summary",
+            approaches: parsed.approaches || [],
+            decisions: parsed.decisions || [],
+            currentState: parsed.currentState || "",
+            nextSteps: parsed.nextSteps || [],
+            filesChanged,
+            filesStaged,
+            recentCommits,
+        };
+        await (0, context_1.saveContext)(entry);
+        console.log(chalk_1.default.green(`\n✓ AI-generated context saved for branch: ${chalk_1.default.bold(branch)}`));
+        console.log(chalk_1.default.cyan(`\n  Task: ${entry.task}`));
+        if (entry.currentState) {
+            console.log(chalk_1.default.gray(`  State: ${entry.currentState}`));
+        }
+        if (entry.decisions.length > 0) {
+            entry.decisions.forEach((d) => console.log(chalk_1.default.gray(`  Decision: ${d}`)));
+        }
+        if (entry.nextSteps.length > 0) {
+            console.log(chalk_1.default.gray(`  Next steps: ${entry.nextSteps.join(", ")}`));
+        }
+        console.log();
+    }
+    catch (err) {
+        console.log(chalk_1.default.red(`✗ Error: ${err.message}`));
+    }
+}

package/dist/commands/watch.d.ts

@@ -0,0 +1,3 @@
+export declare function watchCommand(options?: {
+    interval?: string;
+}): Promise<void>;

package/dist/commands/watch.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchCommand = watchCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const uuid_1 = require("uuid");
+const context_1 = require("../core/context");
+const git_1 = require("../core/git");
+const parser_1 = require("../core/parser");
+const config_1 = require("../utils/config");
+async function watchCommand(options) {
+    if (!(await (0, context_1.isInitialized)())) {
+        console.log(chalk_1.default.red("✗ DevContext not initialized. Run `jarvis init` first."));
+        return;
+    }
+    try {
+        const config = await (0, config_1.loadConfig)();
+        const intervalMinutes = parseInt(options?.interval || String(config.watchInterval), 10);
+        const intervalMs = intervalMinutes * 60 * 1000;
+        const root = await (0, git_1.getRepoRoot)();
+        const devctxDir = await (0, context_1.getDevCtxDir)();
+        let changeCount = 0;
+        let lastSave = Date.now();
+        console.log(chalk_1.default.green("👁  Watch mode started"));
+        console.log(chalk_1.default.gray(`  Auto-save every ${intervalMinutes} minutes when changes detected`));
+        console.log(chalk_1.default.gray(`  Watching: ${root}`));
+        console.log(chalk_1.default.gray("  Press Ctrl+C to stop\n"));
+        const watcher = chokidar_1.default.watch(root, {
+            ignored: [
+                /(^|[\/\\])\../, // dotfiles
+                "**/node_modules/**",
+                "**/dist/**",
+                "**/build/**",
+                "**/.jarvis/**",
+                "**/package-lock.json",
+            ],
+            persistent: true,
+            ignoreInitial: true,
+        });
+        watcher.on("all", (_event, _filePath) => {
+            changeCount++;
+        });
+        // Periodic auto-save
+        const timer = setInterval(async () => {
+            if (changeCount === 0)
+                return;
+            try {
+                const [branch, repo, filesChanged, filesStaged, recentCommits, author] = await Promise.all([
+                    (0, git_1.getCurrentBranch)(),
+                    (0, git_1.getRepoName)(),
+                    (0, git_1.getChangedFiles)(),
+                    (0, git_1.getStagedFiles)(),
+                    (0, git_1.getRecentCommits)(),
+                    (0, git_1.getAuthor)(),
+                ]);
+                // Try to enrich from editor session data
+                const chatContext = await (0, parser_1.extractFromEditorSessions)(root);
+                const entry = {
+                    id: (0, uuid_1.v4)(),
+                    timestamp: new Date().toISOString(),
+                    branch,
+                    repo,
+                    author,
+                    task: chatContext?.task || `Auto-captured: ${changeCount} file changes`,
+                    approaches: chatContext?.approaches || [],
+                    decisions: chatContext?.decisions || [],
+                    currentState: `${changeCount} files changed since last auto-save`,
+                    nextSteps: chatContext?.nextSteps || [],
+                    filesChanged,
+                    filesStaged,
+                    recentCommits,
+                };
+                await (0, context_1.saveContext)(entry);
+                const now = new Date();
+                console.log(chalk_1.default.gray(`  [${now.toLocaleTimeString()}] Auto-saved: ${changeCount} changes on ${branch}`));
+                changeCount = 0;
+                lastSave = Date.now();
+            }
+            catch (err) {
+                console.log(chalk_1.default.yellow(`  ⚠ Auto-save failed: ${err.message}`));
+            }
+        }, intervalMs);
+        // Graceful shutdown
+        const cleanup = () => {
+            clearInterval(timer);
+            watcher.close();
+            console.log(chalk_1.default.gray("\n  Watch mode stopped."));
+            process.exit(0);
+        };
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+    }
+    catch (err) {
+        console.log(chalk_1.default.red(`✗ Error: ${err.message}`));
+    }
+}

package/dist/core/ai.d.ts

@@ -0,0 +1,17 @@
+interface ChatMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+interface AIResponse {
+    content: string;
+    error?: string;
+}
+/**
+ * Call an OpenAI-compatible chat completions API.
+ * Works with OpenAI, Ollama, LM Studio, together.ai, etc.
+ */
+export declare function callAI(messages: ChatMessage[], options?: {
+    maxTokens?: number;
+    temperature?: number;
+}): Promise<AIResponse>;
+export {};