draftify-cli 1.0.0

package/dist/utils/api.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refactorCodeApi = refactorCodeApi;
+exports.getUserProfile = getUserProfile;
+const config_1 = require("./config");
+async function refactorCodeApi(fileName, code, instruction, history, modelName, skillsData, thinkingLevel, onChunk, abortSignal) {
+    const token = (0, config_1.getToken)();
+    if (!token) {
+        throw new Error("No token found. Please run 'draftify login' first.");
+    }
+    const apiUrl = (0, config_1.getApiUrl)();
+    const response = await fetch(apiUrl, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify({ fileName, code, instruction, history, modelName, skillsData, thinkingLevel }),
+        signal: abortSignal
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        let errorMsg = errorText;
+        try {
+            const errorJson = JSON.parse(errorText);
+            errorMsg = errorJson.error || errorText;
+        }
+        catch { }
+        const status = response.status;
+        if (status === 401)
+            throw new Error("Unauthorized: Invalid or expired CLI token. Please login again.");
+        if (status === 403)
+            throw new Error(`Forbidden: ${errorMsg}`);
+        if (status === 429)
+            throw new Error(`Rate Limit Exceeded: ${errorMsg}`);
+        throw new Error(`Server Error (${status}): ${errorMsg}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new Error("No response body from server");
+    const decoder = new TextDecoder("utf-8");
+    let buffer = "";
+    let fullResult = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        let boundary = buffer.indexOf('\n');
+        while (boundary !== -1) {
+            const line = buffer.slice(0, boundary).trim();
+            buffer = buffer.slice(boundary + 1);
+            boundary = buffer.indexOf('\n');
+            if (line.startsWith("data: ") && line !== "data: [DONE]") {
+                try {
+                    const dataObj = JSON.parse(line.slice(6));
+                    let textChunk = dataObj.choices?.[0]?.delta?.content || "";
+                    if (!textChunk && dataObj.candidates && dataObj.candidates.length > 0) {
+                        textChunk = dataObj.candidates[0].content?.parts?.[0]?.text || "";
+                    }
+                    if (textChunk) {
+                        fullResult += textChunk;
+                        if (onChunk)
+                            onChunk(textChunk);
+                    }
+                }
+                catch (e) {
+                    // ignore incomplete json chunk parsing errors
+                }
+            }
+            else if (line.startsWith('{"result":')) {
+                // Fallback for non-streaming response
+                try {
+                    const dataObj = JSON.parse(line);
+                    if (dataObj.result) {
+                        fullResult += dataObj.result;
+                        if (onChunk)
+                            onChunk(dataObj.result);
+                    }
+                }
+                catch (e) { }
+            }
+        }
+    }
+    return fullResult;
+}
+async function getUserProfile() {
+    const token = (0, config_1.getToken)();
+    if (!token)
+        return null;
+    const apiUrl = (0, config_1.getApiUrl)();
+    try {
+        const response = await fetch(apiUrl, {
+            method: "GET",
+            headers: { Authorization: `Bearer ${token}` }
+        });
+        if (response.ok) {
+            const data = await response.json();
+            return { username: data.username, plan: data.plan };
+        }
+    }
+    catch (e) {
+        // Ignore errors
+    }
+    return null;
+}

package/dist/utils/chats.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadChats = loadChats;
+exports.saveChats = saveChats;
+exports.updateChatSession = updateChatSession;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), ".config", "draftify");
+const CHATS_FILE = path_1.default.join(CONFIG_DIR, "chats.json");
+function loadChats() {
+    if (!fs_1.default.existsSync(CHATS_FILE)) {
+        return [];
+    }
+    try {
+        const raw = fs_1.default.readFileSync(CHATS_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+}
+function saveChats(chats) {
+    if (!fs_1.default.existsSync(CONFIG_DIR)) {
+        fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs_1.default.writeFileSync(CHATS_FILE, JSON.stringify(chats, null, 2), "utf-8");
+}
+function updateChatSession(id, title, model, history) {
+    const chats = loadChats();
+    const index = chats.findIndex(c => c.id === id);
+    // Clean title: use first 40 characters of first message or default
+    const cleanTitle = title.replace(/\n/g, " ").substring(0, 40) || "New Chat";
+    const updatedSession = {
+        id,
+        title: cleanTitle,
+        model,
+        history,
+        updatedAt: new Date().toISOString()
+    };
+    if (index !== -1) {
+        chats[index] = updatedSession;
+    }
+    else {
+        chats.unshift(updatedSession); // New session at the top
+    }
+    // Keep last 20 chats
+    saveChats(chats.slice(0, 20));
+}

package/dist/utils/config.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = getConfig;
+exports.saveConfig = saveConfig;
+exports.getToken = getToken;
+exports.getApiUrl = getApiUrl;
+exports.getModel = getModel;
+exports.setModel = setModel;
+exports.getSkills = getSkills;
+exports.setSkills = setSkills;
+exports.getThinkingLevel = getThinkingLevel;
+exports.setThinkingLevel = setThinkingLevel;
+const os_1 = __importDefault(require("os"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), ".config", "draftify");
+const CONFIG_FILE = path_1.default.join(CONFIG_DIR, "config.json");
+function getConfig() {
+    if (!fs_1.default.existsSync(CONFIG_FILE)) {
+        return {};
+    }
+    try {
+        const raw = fs_1.default.readFileSync(CONFIG_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        return {};
+    }
+}
+function saveConfig(newConfig) {
+    const current = getConfig();
+    const merged = { ...current, ...newConfig };
+    if (!fs_1.default.existsSync(CONFIG_DIR)) {
+        fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs_1.default.writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2), {
+        encoding: "utf-8",
+        mode: 0o600, // Secure permissions
+    });
+}
+function getToken() {
+    const config = getConfig();
+    return config.token || null;
+}
+function getApiUrl() {
+    const config = getConfig();
+    // Fallback API URL, overrideable via config or DRAFTIFY_API_URL
+    return process.env.DRAFTIFY_API_URL || config.apiUrl || "http://localhost:3000/api/cli";
+}
+function getModel() {
+    const config = getConfig();
+    return config.model || "Opus 4.7-level";
+}
+function setModel(modelName) {
+    saveConfig({ model: modelName });
+}
+function getSkills() {
+    const config = getConfig();
+    return config.skills || [];
+}
+function setSkills(skills) {
+    saveConfig({ skills });
+}
+function getThinkingLevel() {
+    const config = getConfig();
+    return config.thinkingLevel || 'Medium';
+}
+function setThinkingLevel(level) {
+    saveConfig({ thinkingLevel: level });
+}

package/dist/utils/skills.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableSkills = getAvailableSkills;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+function getAvailableSkills() {
+    const skills = [];
+    const globalSkillsDir = path_1.default.join(os_1.default.homedir(), ".agents", "skills");
+    const localSkillsDir = path_1.default.join(process.cwd(), ".agents", "skills");
+    const scanDir = (dir, source) => {
+        if (!fs_1.default.existsSync(dir))
+            return;
+        try {
+            const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    const skillName = entry.name;
+                    const skillMdPath = path_1.default.join(dir, skillName, "SKILL.md");
+                    if (fs_1.default.existsSync(skillMdPath)) {
+                        const content = fs_1.default.readFileSync(skillMdPath, "utf-8");
+                        // Only add if not already added (local overrides global if same name)
+                        if (!skills.some(s => s.name === skillName)) {
+                            skills.push({
+                                name: skillName,
+                                content,
+                                source
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        catch (e) {
+            // Ignore read errors
+        }
+    };
+    // Local first so it takes precedence over global
+    scanDir(localSkillsDir, "local");
+    scanDir(globalSkillsDir, "global");
+    return skills;
+}

package/dist/utils/ui.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ui = void 0;
+exports.createSpinner = createSpinner;
+const kleur_1 = require("kleur");
+const ora_1 = __importDefault(require("ora"));
+// Bento-style minimalist & Claude-style orange UI
+exports.ui = {
+    header: (text) => console.log(`\n${(0, kleur_1.bold)(text)}`),
+    step: (text) => console.log(`  ${(0, kleur_1.dim)("│")}  ${text}`),
+    info: (text) => console.log(`  ${(0, kleur_1.dim)("│")}  ${(0, kleur_1.dim)(text)}`),
+    success: (text) => console.log(`  ${(0, kleur_1.dim)("└")}  ${(0, kleur_1.bold)(text)}\n`),
+    error: (text) => console.log(`\n  ${(0, kleur_1.bold)("x")}  ${text}\n`),
+    fileAction: (text) => {
+        const greenCheck = `\x1b[32m✓\x1b[0m`;
+        console.log(`  ${greenCheck} ${text}`);
+    },
+    fileRead: (filePath) => {
+        const icon = `\x1b[36m›\x1b[0m`;
+        const gray = (s) => `\x1b[90m${s}\x1b[0m`;
+        console.log(`  ${icon} ${gray("Reading:")} ${filePath}`);
+    },
+    fileCreate: (filePath) => {
+        const icon = `\x1b[32m+\x1b[0m`;
+        const gray = (s) => `\x1b[90m${s}\x1b[0m`;
+        console.log(`  ${icon} ${gray("Creating:")} \x1b[32m${filePath}\x1b[0m`);
+    },
+    fileModify: (filePath) => {
+        const icon = `\x1b[33m~\x1b[0m`;
+        const gray = (s) => `\x1b[90m${s}\x1b[0m`;
+        console.log(`  ${icon} ${gray("Modifying:")} \x1b[33m${filePath}\x1b[0m`);
+    },
+    fileDelete: (filePath) => {
+        const icon = `\x1b[31m-\x1b[0m`;
+        const gray = (s) => `\x1b[90m${s}\x1b[0m`;
+        console.log(`  ${icon} ${gray("Deleting:")} \x1b[31m${filePath}\x1b[0m`);
+    },
+    fileSuccess: (action, filePath) => {
+        const check = `\x1b[32m✓\x1b[0m`;
+        console.log(`  ${check} ${action}: ${filePath}`);
+    },
+    divider: () => console.log((0, kleur_1.dim)("──────────────────────────────────────────")),
+    blank: () => console.log(""),
+    // Claude Code style orange box with terminal-width-aware wrapping
+    box: (title, lines) => {
+        const terminalWidth = process.stdout.columns || 80;
+        const maxBoxWidth = Math.max(40, Math.min(100, terminalWidth - 8));
+        const stripAnsi = (str) => str.replace(/\u001b\[[0-9;]*m/g, '');
+        const processedLines = [];
+        for (const line of lines) {
+            const plainLength = stripAnsi(line).length;
+            if (plainLength <= maxBoxWidth) {
+                processedLines.push(line);
+            }
+            else {
+                const words = line.split(" ");
+                let currentLine = "";
+                for (const word of words) {
+                    const currentLinePlain = stripAnsi(currentLine).length;
+                    const wordPlain = stripAnsi(word).length;
+                    if (currentLinePlain + wordPlain + (currentLine ? 1 : 0) > maxBoxWidth) {
+                        if (currentLine) {
+                            processedLines.push(currentLine);
+                            currentLine = word;
+                        }
+                        else {
+                            processedLines.push(word);
+                            currentLine = "";
+                        }
+                    }
+                    else {
+                        currentLine = currentLine ? currentLine + " " + word : word;
+                    }
+                }
+                if (currentLine) {
+                    processedLines.push(currentLine);
+                }
+            }
+        }
+        const width = Math.max(title.length + 4, ...processedLines.map(l => stripAnsi(l).length), 40);
+        console.log((0, kleur_1.yellow)(`╭─ ${title} ${"─".repeat(width - title.length - 3)}╮`));
+        processedLines.forEach(line => {
+            const plainLength = stripAnsi(line).length;
+            console.log((0, kleur_1.yellow)("│ ") + line + " ".repeat(Math.max(0, width - plainLength)) + (0, kleur_1.yellow)(" │"));
+        });
+        console.log((0, kleur_1.yellow)(`╰${"─".repeat(width + 2)}╯`));
+    },
+    // Minimalist status line for REPL
+    statusLine: (repoName, model) => {
+        const text = `Draftify Scale | Engine: ${model} | Repo: ${repoName}`;
+        console.log(`\n  ${(0, kleur_1.dim)(`[${text}]`)}`);
+    },
+    welcomeScreen: (repoName, model, username, plan = "Draftify Scale", thinkingLevel = "Medium") => {
+        // Borderless Claude Code style with strong orange logo
+        const orange = (s) => `\x1b[38;5;208m${s}\x1b[0m`;
+        const gray = (s) => `\x1b[90m${s}\x1b[0m`;
+        const white = (s) => `\x1b[37m${s}\x1b[0m`;
+        console.log("");
+        const greeting = username ? `Welcome ${username} to Draftify Code!` : "Welcome to Draftify Code!";
+        console.log(`  ${orange("█ █   █ █")}  ${white(greeting)}`);
+        console.log(`  ${orange("█████████")}  ${white("Draftify Code ")}${gray("v1.0.0")}`);
+        console.log(`  ${orange("█ █████ █")}  ${gray(`${model} | Thinking: ${thinkingLevel}  [${plan}]`)}`);
+        console.log(`  ${orange("█████████")}  ${gray(process.cwd())}`);
+        console.log(`  ${orange(" █     █ ")}`);
+        console.log("");
+    }
+};
+function createSpinner(text) {
+    const startTime = Date.now();
+    let currentText = text;
+    const spinner = (0, ora_1.default)({
+        text: (0, kleur_1.dim)(`${currentText} 0.0s`),
+        spinner: {
+            interval: 120,
+            frames: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+        },
+        color: "white",
+    });
+    const timer = setInterval(() => {
+        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+        spinner.text = (0, kleur_1.dim)(`${currentText} ${elapsed}s`);
+    }, 100);
+    const originalStop = spinner.stop.bind(spinner);
+    spinner.stop = () => {
+        clearInterval(timer);
+        return originalStop();
+    };
+    spinner.setPrefix = (newText) => {
+        currentText = newText;
+    };
+    return spinner;
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "draftify-cli",
+  "version": "1.0.0",
+  "description": "Draftify AI CLI tool",
+  "main": "dist/index.js",
+  "bin": {
+    "draftify": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "draftify",
+    "cli",
+    "ai",
+    "assistant"
+  ],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "ansi-escapes": "^7.3.0",
+    "axios": "^1.7.2",
+    "commander": "^12.1.0",
+    "enquirer": "^2.4.1",
+    "kleur": "^4.1.5",
+    "open": "^8.4.2",
+    "ora": "^5.4.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.2",
+    "typescript": "^5.4.5"
+  }
+}