@taj-special/dravix-code 1.1.1

package/dist/services/ai.js

@@ -0,0 +1,206 @@
+const AI_PROXY = 'https://dravix.app/ai-proxy.php';
+const PROMPT_URL = 'https://dravix.app/cli-prompt.php';
+export async function fetchSystemPrompt(token) {
+    try {
+        const res = await fetch(`${PROMPT_URL}?token=${encodeURIComponent(token)}`, {
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!res.ok)
+            return { prompt: '', webDesignerSkill: '', isCreator: false };
+        const data = await res.json();
+        return {
+            prompt: data.prompt ?? '',
+            webDesignerSkill: data.web_designer_skill ?? '',
+            isCreator: data.is_creator ?? false,
+        };
+    }
+    catch {
+        return { prompt: '', webDesignerSkill: '', isCreator: false };
+    }
+}
+const TIMEOUT_MS = 300_000; // 5 min — AI may generate large responses
+const CHUNK_TIMEOUT_MS = 60_000; // 1 min without any chunk = abort
+const MAX_CONTINUATIONS = 5; // auto-continue up to 5 times on length cutoff
+// Convert history to OpenAI-compatible format:
+// Only the first message can be role:system — everything else must alternate user/assistant.
+// Mid-conversation system messages (file contents, /add files) become role:user.
+// Consecutive user/system-as-user messages are merged to maintain proper alternation.
+function prepareMessages(messages) {
+    // Trim context: if total chars exceed ~180k (~45k tokens), drop oldest non-system messages
+    const MAX_CHARS = 80_000;
+    let totalChars = messages.reduce((s, m) => s + String(m.content).length, 0);
+    const trimmed = [...messages];
+    while (totalChars > MAX_CHARS && trimmed.length > 4) {
+        const removed = trimmed.splice(1, 1)[0];
+        totalChars -= String(removed.content).length;
+    }
+    const converted = trimmed.map((msg, i) => {
+        if (msg.role === 'system' && i > 0)
+            return { role: 'user', content: msg.content };
+        return msg;
+    });
+    const merged = [];
+    for (const msg of converted) {
+        const last = merged[merged.length - 1];
+        if (last && last.role === 'user' && msg.role === 'user') {
+            last.content = last.content + '\n\n' + msg.content;
+        }
+        else {
+            merged.push({ ...msg });
+        }
+    }
+    return merged;
+}
+async function doSingleRequest(messages, token, abort, onChunk) {
+    const requestTimer = setTimeout(() => abort.abort(), TIMEOUT_MS);
+    try {
+        const res = await fetch(AI_PROXY, {
+            method: 'POST',
+            signal: abort.signal,
+            headers: {
+                'Content-Type': 'application/json',
+                'X-CLI-Token': token,
+                'X-CLI-Version': '1.1.0',
+            },
+            body: JSON.stringify({
+                provider: 'openrouter',
+                model: 'deepseek/deepseek-v4-flash',
+                messages: prepareMessages(messages),
+                stream: true,
+                temperature: 0.1,
+                max_tokens: 16384,
+            }),
+        });
+        if (!res.ok || !res.body) {
+            const text = await res.text().catch(() => '');
+            let msg = `HTTP ${res.status}`;
+            try {
+                msg = JSON.parse(text).error ?? msg;
+            }
+            catch { }
+            throw new Error(msg);
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let finishReason = 'stop';
+        let chunkResponse = '';
+        outer: while (true) {
+            let chunkTimer = setTimeout(() => abort.abort(), CHUNK_TIMEOUT_MS);
+            const { done, value } = await reader.read().finally(() => {
+                if (chunkTimer) {
+                    clearTimeout(chunkTimer);
+                    chunkTimer = null;
+                }
+            });
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                if (!line.startsWith('data: '))
+                    continue;
+                const data = line.slice(6).trim();
+                if (data === '[DONE]')
+                    break outer;
+                let json;
+                try {
+                    json = JSON.parse(data);
+                }
+                catch {
+                    continue;
+                }
+                // Detect API/proxy error events in the SSE stream — was previously silently ignored
+                if (json.error) {
+                    const e = json.error;
+                    const msg = typeof e.message === 'string' ? e.message
+                        : typeof json.error === 'string' ? json.error
+                            : JSON.stringify(json.error);
+                    throw new Error(msg);
+                }
+                const choices = json.choices;
+                const delta = choices?.[0]?.delta;
+                const text = (delta?.content ?? '');
+                const rawFr = (choices?.[0]?.finish_reason ?? '');
+                if (rawFr && rawFr !== 'null')
+                    finishReason = rawFr;
+                if (text) {
+                    chunkResponse += text;
+                    onChunk(text);
+                }
+            }
+        }
+        // Detect non-SSE JSON error body (e.g. proxy returns plain JSON error instead of SSE)
+        if (!chunkResponse) {
+            if (buffer.trim()) {
+                try {
+                    const errData = JSON.parse(buffer.trim());
+                    if (errData.error) {
+                        const e = errData.error;
+                        const msg = typeof e.message === 'string' ? e.message
+                            : typeof errData.error === 'string' ? errData.error
+                                : JSON.stringify(errData.error);
+                        throw new Error(msg);
+                    }
+                }
+                catch (pe) {
+                    if (!(pe instanceof SyntaxError))
+                        throw pe;
+                }
+            }
+            if (!finishReason || finishReason === 'stop') {
+                throw new Error('No response from AI — check your connection or try again');
+            }
+        }
+        return { finishReason, response: chunkResponse };
+    }
+    finally {
+        clearTimeout(requestTimer);
+    }
+}
+export async function streamChat(messages, token, onChunk, onDone, onError, cancelSignal) {
+    const abort = new AbortController();
+    const forwardCancel = () => abort.abort();
+    cancelSignal?.addEventListener('abort', forwardCancel);
+    try {
+        let currentMessages = [...messages];
+        for (let attempt = 0; attempt <= MAX_CONTINUATIONS; attempt++) {
+            if (cancelSignal?.aborted) {
+                onDone();
+                return;
+            }
+            const { finishReason, response } = await doSingleRequest(currentMessages, token, abort, onChunk);
+            if (finishReason === 'length' && attempt < MAX_CONTINUATIONS) {
+                // Token limit hit — auto-continue seamlessly, no visible break to user
+                const tail = response.slice(-400);
+                // Detect if cut off inside an open tag — need to complete it first
+                const openTagMatch = response.match(/<(write_file|edit_file|run_command|read_file|search_code)[^>]*>(?:(?!<\/\1>)[\s\S])*$/);
+                const contPrompt = openTagMatch
+                    ? `Your previous response was cut off inside a <${openTagMatch[1]}> tag. The tail was:\n"...${tail}"\nFirst COMPLETE the current tag (close it properly), then continue with any remaining work. Output ONLY the raw continuation — no intro, no preamble.`
+                    : `Your previous response was cut off. It ended with:\n"...${tail}"\nContinue from that exact point — complete any remaining file edits or tasks. Output ONLY the raw continuation — no intro, no preamble, no repeated text.`;
+                currentMessages = [
+                    ...currentMessages,
+                    { role: 'assistant', content: response },
+                    { role: 'user', content: contPrompt },
+                ];
+                continue;
+            }
+            break;
+        }
+        onDone();
+    }
+    catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        if (e.name === 'AbortError' && cancelSignal?.aborted) {
+            onDone(); // user-initiated cancel → clean stop with partial response
+        }
+        else {
+            const msg = e.name === 'AbortError' ? 'Request timed out — check your connection.' : e.message;
+            onError(new Error(msg));
+        }
+    }
+    finally {
+        cancelSignal?.removeEventListener('abort', forwardCancel);
+    }
+}

package/dist/services/auth.js

@@ -0,0 +1,67 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const CONFIG_DIR = path.join(os.homedir(), '.dravix-code');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const AUTH_URL = 'https://dravix.app/cli-auth';
+const VERIFY_URL = 'https://dravix.app/cli-auth?action=verify&token=';
+function readConfig() {
+    try {
+        return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function writeConfig(config) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+}
+export function saveConfig(config) {
+    writeConfig(config);
+}
+export function getToken() {
+    return readConfig().token ?? null;
+}
+export function getSavedUser() {
+    const c = readConfig();
+    return { name: c.name, email: c.email };
+}
+export function isLoggedIn() {
+    return !!getToken();
+}
+export function logout() {
+    const config = readConfig();
+    delete config.token;
+    delete config.name;
+    delete config.email;
+    writeConfig(config);
+}
+export async function verifyAndSave(token) {
+    try {
+        const res = await fetch(VERIFY_URL + encodeURIComponent(token));
+        const data = await res.json();
+        if (!data.valid)
+            return null;
+        writeConfig({ token, name: data.name ?? '', email: data.email ?? '' });
+        return { name: data.name ?? '', email: data.email ?? '' };
+    }
+    catch {
+        return null;
+    }
+}
+export async function checkPlan(email) {
+    try {
+        const res = await fetch('https://dravix.app/check_user_plus.php', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ email }),
+        });
+        const data = await res.json();
+        return data.isPlus ? 'Plus' : 'Free';
+    }
+    catch {
+        return 'Free';
+    }
+}
+export { AUTH_URL };

package/dist/services/context.js

@@ -0,0 +1,128 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+const IGNORE = new Set([
+    'node_modules', '.git', 'dist', 'build', '.next', 'out',
+    '__pycache__', '.cache', 'coverage', '.turbo',
+]);
+const CODE_EXTS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.py', '.html', '.css', '.scss',
+    '.json', '.md', '.txt', '.sh', '.php', '.sql', '.yaml', '.yml',
+    '.java', '.go', '.rs', '.c', '.cpp', '.h', '.vue', '.svelte',
+]);
+export function getProjectFiles(root, maxFiles = 30) {
+    const files = [];
+    function walk(dir, depth = 0) {
+        if (depth > 4 || files.length >= maxFiles)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (IGNORE.has(e.name) || e.name.startsWith('.'))
+                continue;
+            const fullPath = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                walk(fullPath, depth + 1);
+            }
+            else if (CODE_EXTS.has(path.extname(e.name).toLowerCase())) {
+                files.push(path.relative(root, fullPath));
+            }
+        }
+    }
+    walk(root);
+    return files;
+}
+export function readFileContent(filePath, maxLen = 8000) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        if (content.length > maxLen)
+            return content.slice(0, maxLen) + '\n... (truncated)';
+        return content;
+    }
+    catch {
+        return '';
+    }
+}
+export function getGitStatus(root) {
+    try {
+        return execSync('git status --short', {
+            cwd: root,
+            encoding: 'utf-8',
+            timeout: 5000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+const STOP_WORDS = new Set([
+    'this', 'that', 'with', 'from', 'have', 'will', 'what', 'when', 'where', 'make', 'into',
+    'does', 'should', 'would', 'could', 'then', 'they', 'your', 'just', 'also', 'more',
+    // Tajik/Farsi common words
+    'дустам', 'хамин', 'барои', 'метавонед', 'кунед', 'мекунад', 'мешавад', 'аст',
+    'ман', 'хам', 'хамон', 'дар', 'ва', 'ки', 'ба', 'аз', 'он', 'буд', 'мебошад', 'кун',
+]);
+/**
+ * Extract only the relevant sections of a large file based on user message keywords.
+ * Returns numbered lines with context around each match.
+ */
+export function extractRelevantSections(fileContent, userMessage, contextLines = 35) {
+    const lines = fileContent.split('\n');
+    const total = lines.length;
+    // Extract latin technical keywords (CSS classes, HTML tags, JS identifiers)
+    const keywords = [...new Set(userMessage
+            .toLowerCase()
+            .split(/[\s.,!?;:()\[\]{}'"`\/\\]+/)
+            .filter(w => w.length >= 3 && !STOP_WORDS.has(w) && /^[\w\-]+$/.test(w)))];
+    if (keywords.length === 0) {
+        // No latin keywords — return structural preview
+        const preview = lines.slice(0, 80).map((l, i) => `${String(i + 1).padStart(4)} │ ${l}`).join('\n');
+        return `[File: ${total} lines — no specific keywords found. First 80 lines shown.]\n${preview}\n[Use <read_file lines="N-M"/> to read any other section]`;
+    }
+    // Find lines matching any keyword
+    const included = new Set();
+    for (let i = 0; i < lines.length; i++) {
+        const low = lines[i].toLowerCase();
+        if (keywords.some(kw => low.includes(kw))) {
+            const from = Math.max(0, i - contextLines);
+            const to = Math.min(total - 1, i + contextLines);
+            for (let c = from; c <= to; c++)
+                included.add(c);
+        }
+    }
+    if (included.size === 0) {
+        const preview = lines.slice(0, 80).map((l, i) => `${String(i + 1).padStart(4)} │ ${l}`).join('\n');
+        return `[File: ${total} lines — keywords [${keywords.slice(0, 5).join(', ')}] not found. First 80 lines shown.]\n${preview}\n[Use <search_code> to find specific text]`;
+    }
+    const sorted = [...included].sort((a, b) => a - b);
+    const out = [
+        `[File: ${total} lines — showing ${included.size} relevant lines for: ${keywords.slice(0, 6).join(', ')}]`,
+        `[⚠ In <find>: copy ONLY the text AFTER " │ " — never include line numbers]`,
+    ];
+    let prev = -2;
+    for (const idx of sorted) {
+        if (idx > prev + 1)
+            out.push('     ···');
+        out.push(`${String(idx + 1).padStart(4)} │ ${lines[idx]}`);
+        prev = idx;
+    }
+    out.push(`[Use <read_file lines="N-M"/> to read any section not shown above]`);
+    return out.join('\n');
+}
+export function buildContext(root) {
+    const files = getProjectFiles(root);
+    const git = getGitStatus(root);
+    const projectName = path.basename(root);
+    return `Project: ${projectName}
+Working dir: ${root}
+Git status:
+${git || '(clean)'}
+Files:
+${files.length > 0 ? files.join('\n') : '(empty project)'}`;
+}

package/dist/services/conversations.js

@@ -0,0 +1,62 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const CONV_DIR = path.join(os.homedir(), '.dravix-code', 'conversations');
+function ensureDir() {
+    fs.mkdirSync(CONV_DIR, { recursive: true });
+}
+export function generateId() {
+    return Date.now().toString(36) + Math.random().toString(36).slice(2, 9) + Math.random().toString(36).slice(2, 5);
+}
+export function generateTitle(messages) {
+    const first = messages.find(m => m.role === 'user');
+    if (!first)
+        return 'New conversation';
+    return String(first.content).replace(/\s+/g, ' ').trim().slice(0, 60) || 'New conversation';
+}
+export function saveConversation(id, title, cwd, messages) {
+    const chat = messages.filter(m => m.role === 'user' || m.role === 'assistant');
+    if (chat.length === 0)
+        return;
+    ensureDir();
+    const data = {
+        id, title, cwd,
+        updatedAt: new Date().toISOString(),
+        messageCount: chat.length,
+        messages,
+    };
+    try {
+        fs.writeFileSync(path.join(CONV_DIR, `${id}.json`), JSON.stringify(data), 'utf-8');
+    }
+    catch { /* ignore write errors */ }
+}
+export function loadConversation(id) {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(CONV_DIR, `${id}.json`), 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function listConversations(limit = 30) {
+    ensureDir();
+    try {
+        return fs.readdirSync(CONV_DIR)
+            .filter(f => f.endsWith('.json'))
+            .map(f => {
+            try {
+                const c = JSON.parse(fs.readFileSync(path.join(CONV_DIR, f), 'utf-8'));
+                return { id: c.id, title: c.title, cwd: c.cwd, updatedAt: c.updatedAt, messageCount: c.messageCount };
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((c) => c !== null)
+            .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())
+            .slice(0, limit);
+    }
+    catch {
+        return [];
+    }
+}