termux-dev 1.5.0 → 1.8.0

package/dist/core/network.js

@@ -1,6 +1,7 @@
 /**
  * Network Resilience & Error Utilities for devx
  */
+import { t } from './i18n.js';
 export function isNetworkOrRetryableError(err) {
     if (!err)
         return false;
@@ -70,45 +71,45 @@ export function isNetworkOrRetryableError(err) {
 }
 export function getHumanReadableNetworkError(err) {
     if (!err)
-        return 'Неизвестная ошибка сети (Network error)';
+        return t('net.unknown');
     const msg = (err.message || String(err)).toLowerCase();
     const code = (err.code || err.cause?.code || '').toLowerCase();
     const status = err.status || err.statusCode || 0;
     if (status === 429 || msg.includes('429') || msg.includes('rate limit')) {
-        return 'Превышен лимит запросов API (Rate limit / 429)';
+        return t('net.rateLimit');
     }
     if (status === 502 || msg.includes('502') || msg.includes('bad gateway')) {
-        return 'Шлюз провайдера временно недоступен (Bad Gateway / 502)';
+        return t('net.badGateway');
     }
     if (status === 503 || msg.includes('503') || msg.includes('service unavailable')) {
-        return 'Сервер провайдера перегружен (Service Unavailable / 503)';
+        return t('net.unavailable');
     }
     if (status === 504 || msg.includes('504') || msg.includes('gateway timeout')) {
-        return 'Таймаут шлюза провайдера (Gateway Timeout / 504)';
+        return t('net.gatewayTimeout');
     }
     if (code.includes('enotfound') || msg.includes('enotfound') || code.includes('eai_again')) {
-        return 'Нет подключения к сети или DNS (Host not found / Offline)';
+        return t('net.offline');
     }
     if (code.includes('econnreset') ||
         msg.includes('econnreset') ||
         msg.includes('connection reset') ||
         msg.includes('socket hang up') ||
         msg.includes('terminated')) {
-        return 'Обрыв соединения с сервером (Connection reset / Socket closed)';
+        return t('net.reset');
     }
     if (code.includes('etimedout') ||
         msg.includes('timeout') ||
         msg.includes('time out') ||
         code.includes('und_err_connect_timeout')) {
-        return 'Таймаут сетевого соединения (Network timeout)';
+        return t('net.timeout');
     }
     if (code.includes('econnrefused') || msg.includes('connection refused')) {
-        return 'Сервер отклонил подключение (Connection refused)';
+        return t('net.refused');
     }
     if (msg.includes('fetch failed')) {
-        return 'Сбой сетевого соединения (Fetch failed / Connection dropped)';
+        return t('net.fetchFailed');
     }
-    return err.message || 'Сбой интернет-соединения';
+    return err.message || t('net.generic');
 }
 export function waitDelay(ms, signal) {
     return new Promise((resolve) => {

package/dist/core/notify.js

@@ -52,3 +52,57 @@ export function notifyDevice(title, message, options = { vibrate: true, sound: t
         }
     }
 }
+// ───────────────────────── desktop notification when the terminal is not in front ─────────────────────────
+/** The start of an answer as plain text for a notification: no markdown, code or links, cut at a word. */
+export function notificationBody(markdown, max = 160) {
+    let text = String(markdown ?? '')
+        .replace(/```[\s\S]*?(```|$)/g, ' ')
+        .replace(/`([^`]*)`/g, '$1')
+        .replace(/!?\[([^\]]*)\]\([^)]*\)/g, '$1')
+        .replace(/^\s{0,3}(#{1,6}|>|[-*+]|\d+[.)])\s+/gm, '')
+        .replace(/[*_~]{1,3}([^*_~\n]+)[*_~]{1,3}/g, '$1')
+        .replace(/[\x00-\x1f\x7f]/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (Array.from(text).length <= max)
+        return text;
+    const cut = Array.from(text).slice(0, max).join('');
+    text = cut.replace(/\s+\S*$/, '') || cut;
+    return text.replace(/[\s,;:.\-]+$/, '') + '…';
+}
+/** kitty's own notification protocol (OSC 99): a title, then the body of the same notification. */
+export function kittyNotificationSequence(title, body) {
+    const clean = (s) => s.replace(/[\x00-\x1f\x7f]/g, ' ');
+    return `\x1b]99;i=devx:d=0;${clean(title)}\x1b\\\x1b]99;i=devx:p=body;${clean(body)}\x1b\\`;
+}
+/**
+ * Shows a notification on the desktop: through kitty's protocol in kitty, `notify-send` on Linux,
+ * `osascript` on macOS. Returns which way was used, or 'none'. Never throws.
+ */
+export function sendDesktopNotification(title, body, io = {}) {
+    const platform = io.platform ?? process.platform;
+    const env = io.env ?? process.env;
+    const write = io.write ?? ((text) => process.stdout.write(text));
+    const run = io.run ?? ((command, args) => {
+        const child = spawn(command, args, { stdio: 'ignore', detached: true });
+        child.on('error', () => { });
+        child.unref();
+    });
+    try {
+        if (env.KITTY_WINDOW_ID) {
+            write(kittyNotificationSequence(title, body));
+            return 'kitty';
+        }
+        if (platform === 'linux') {
+            run('notify-send', ['--app-name=devx', title, body]);
+            return 'notify-send';
+        }
+        if (platform === 'darwin') {
+            const q = (s) => `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+            run('osascript', ['-e', `display notification ${q(body)} with title ${q(title)}`]);
+            return 'osascript';
+        }
+    }
+    catch { }
+    return 'none';
+}

package/dist/core/planfile.js

@@ -0,0 +1,43 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+const planFile = (cwd) => path.join(cwd, '.devx', 'plan.md');
+export const PLAN_FRESH_MS = 24 * 60 * 60 * 1000;
+export const PLAN_PROMPT_MAX_CHARS = 3000;
+export function planToMarkdown(plan, when = new Date()) {
+    const stamp = when.toISOString().slice(0, 16).replace('T', ' ');
+    const lines = ['# Plan', '', `_Approved ${stamp}_`, '', plan.summary.trim(), ''];
+    const files = (plan.files ?? []).filter(Boolean);
+    if (files.length > 0)
+        lines.push('## Files', '', ...files.map((f) => `- ${f}`), '');
+    const steps = (plan.steps ?? []).filter(Boolean);
+    if (steps.length > 0)
+        lines.push('## Steps', '', ...steps.map((s, i) => `${i + 1}. ${s}`), '');
+    return lines.join('\n');
+}
+/** Writes the plan (structured data, or the text of a plan the model wrote in its answer). Returns the path. */
+export async function savePlanFile(cwd, plan, when = new Date()) {
+    const markdown = typeof plan === 'string'
+        ? `# Plan\n\n_Approved ${when.toISOString().slice(0, 16).replace('T', ' ')}_\n\n${plan.trim()}\n`
+        : planToMarkdown(plan, when);
+    const file = planFile(cwd);
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await fs.writeFile(file, markdown, 'utf8');
+    return file;
+}
+/** The plan for the system prompt: only if it is recent, cut to a size that does not eat the context. */
+export function loadPlanForPrompt(cwd, now = Date.now()) {
+    const file = planFile(cwd);
+    try {
+        const stat = fsSync.statSync(file);
+        if (now - stat.mtimeMs > PLAN_FRESH_MS)
+            return '';
+        const text = fsSync.readFileSync(file, 'utf8').trim();
+        if (text.length <= PLAN_PROMPT_MAX_CHARS)
+            return text;
+        return text.slice(0, PLAN_PROMPT_MAX_CHARS).replace(/\n[^\n]*$/, '') + '\n… (the rest is in .devx/plan.md)';
+    }
+    catch {
+        return '';
+    }
+}