zedev-cli 0.1.0

package/README.md

@@ -0,0 +1,86 @@
+# zedev — əmr sətri
+
+Şirkət qaydalarını qovluqdan ZEDEV platformasına göndərir. Brauzer açmağa,
+fayl seçməyə, dialoqdan keçməyə ehtiyac yoxdur:
+
+```bash
+zedev push --publish
+```
+
+## Quraşdırma
+
+Node 18.17+ lazımdır. Asılılığı yoxdur.
+
+```bash
+npm i -g zedev-cli
+```
+
+Hələ npm-ə dərc olunmayıbsa, repo-dan:
+
+```bash
+npm i -g ./cli
+```
+
+## İlk dəfə
+
+1. Platformada **Standart dəstləri** → dəstin kartında **«CLI açarı»** → açarı kopyala
+   (bir dəfə göstərilir).
+2. Terminalda:
+
+```bash
+zedev login --key zedev_xxxxxxxx
+```
+
+Açar `~/.zedev/config.json`-a yazılır (yalnız sənin oxuya biləcəyin fayl).
+**Repo qovluğuna heç nə yazılmır** — açar səhvən commit olunmasın deyə.
+
+3. Qaydaların olduğu qovluqda:
+
+```bash
+zedev push --publish
+```
+
+## Əmrlər
+
+| Əmr | Nə edir |
+|---|---|
+| `zedev login --key … [--server …]` | açarı yoxlayır və saxlayır |
+| `zedev push [qovluq]` | qovluğu **qaralamaya** göndərir |
+| `zedev push --publish --note "…"` | göndərir və komandaya **dərc edir** |
+| `zedev push --dry-run -v` | heç nə göndərmir, nə gedəcəyini göstərir |
+| `zedev push --delete-missing` | qovluqda olmayan faylları qaralamadan silir |
+| `zedev watch [qovluq]` | dəyişiklikləri izləyir, avtomatik göndərir |
+| `zedev status` | açar hara baxır, nə dərc olunub |
+| `zedev init` | qovluğa `.zedev.json` (hədəf) yazır |
+| `zedev profiles` · `use` · `logout` | bir neçə server/açar |
+
+## İki fayl, iki məsuliyyət
+
+| Fayl | Nə saxlayır | Paylaşıla bilər? |
+|---|---|---|
+| `~/.zedev/config.json` | **açar** + server | ❌ heç vaxt |
+| qovluqdakı `.zedev.json` | hansı profil, dərc etsinmi | ✅ bəli, sirr yoxdur |
+
+CI üçün fayl lazım deyil: `ZEDEV_KEY` və `ZEDEV_SERVER` mühit dəyişənləri işləyir.
+
+```yaml
+- run: npx zedev-cli push --publish --note "$GITHUB_SHA"
+  env:
+    ZEDEV_KEY: ${{ secrets.ZEDEV_KEY }}
+    ZEDEV_SERVER: https://dev.zestudio.az
+```
+
+## Nə göndərilmir
+
+`node_modules`, `.git`, `dist`, `build`, `bin`, `obj`, `.vscode`, `.idea`, `coverage`
+və OS/VCS xidmət faylları (`.DS_Store`, `.gitignore`, …). Fayl limiti **2 MB**,
+ümumi **20 MB** — vebdəki yükləmə ilə eyni qaydalar.
+
+## Susqun davranışlar (qəsdən)
+
+- **Heç nə silinmir.** Qovluqdan çıxardığın fayl platformada qalır; silmək üçün
+  `--delete-missing` yazmalısan.
+- **Dərc ayrıca qərardır.** `push` qaralamaya yazır; komanda onu yalnız `--publish`
+  (və ya platformada «Dərc et») sonra görür.
+- **`watch` dərc etmir.** Yazı prosesində hər saxlama yeni versiya olsaydı, versiya
+  jurnalı mənasını itirərdi.

package/bin/zedev.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { login } from '../src/commands/login.js';
+import { push } from '../src/commands/push.js';
+import { watch } from '../src/commands/watch.js';
+import { status, init, profiles, logout, use } from '../src/commands/misc.js';
+import { parse } from '../src/args.js';
+import { fail, info, bold, dim, cyan } from '../src/ui.js';
+
+/**
+ * ZEDEV CLI — şirkət qaydalarını qovluqdan platformaya göndərir.
+ *
+ * Asılılıq YOXDUR (Node 18+ `fetch`): `npm i -g` bir saniyə çəkir və gələcəkdə
+ * asılılıq zəncirindən gələn təhlükəsizlik xəbərdarlığı olmur. Alət nə qədər kiçikdirsə,
+ * o qədər uzun yaşayır.
+ */
+
+const HELP = `
+${bold('zedev')} — ZEDEV standartları üçün əmr sətri
+
+${bold('Əmrlər')}
+  ${cyan('login')} --key zedev_… [--server https://…] [--as ad]
+        Açarı yoxlayır və ~/.zedev/config.json-a yazır
+  ${cyan('push')} [qovluq] [--publish] [--note "…"] [--delete-missing] [--dry-run] [-v]
+        Qovluğu qaralamaya göndərir; --publish komandaya dərc edir
+  ${cyan('watch')} [qovluq] [--publish]
+        Dəyişiklikləri izləyir və avtomatik göndərir
+  ${cyan('status')} [qovluq]
+        Açar hara baxır, nə dərc olunub, qovluqda nə var
+  ${cyan('init')} [qovluq] [--publish] [--force]
+        Qovluğa .zedev.json (hədəf) yazır — açar YOX, sirr daşımır
+  ${cyan('profiles')} · ${cyan('use')} <ad> · ${cyan('logout')} [ad]
+        Bir neçə server/açar arasında keçid
+
+${bold('Ümumi bayraqlar')}
+  --key, --server, --profile   konfiqi bir dəfəlik əvəz edir
+  ZEDEV_KEY, ZEDEV_SERVER, ZEDEV_PROFILE mühit dəyişənləri (CI üçün)
+
+${dim('Açarı platformada: Standart dəstləri → dəst → «CLI açarı».')}
+`;
+
+const version = async () => {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const pkg = JSON.parse(await readFile(path.join(here, '..', 'package.json'), 'utf8'));
+  return pkg.version;
+};
+
+const [, , cmd, ...rest] = process.argv;
+const { args, flags } = parse(rest);
+
+try {
+  if (!cmd || flags.help || cmd === 'help' || cmd === '--help') { info(HELP); process.exit(0); }
+  if (cmd === '--version' || cmd === 'version') { info(await version()); process.exit(0); }
+
+  switch (cmd) {
+    case 'login': await login(flags); break;
+    case 'push': await push(args, flags); break;
+    case 'watch': await watch(args, flags); break;
+    case 'status': await status(args, flags); break;
+    case 'init': await init(args, flags); break;
+    case 'profiles': await profiles(); break;
+    case 'use': await use(args); break;
+    case 'logout': await logout(args); break;
+    default:
+      fail(`Naməlum əmr: ${cmd}`);
+      info(HELP);
+      process.exit(2);
+  }
+} catch (e) {
+  fail(e.message);
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "zedev-cli",
+  "version": "0.1.0",
+  "description": "ZEDEV — şirkət qaydalarını qovluqdan bir əmrlə platformaya göndər",
+  "type": "module",
+  "bin": {
+    "zedev": "bin/zedev.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.17"
+  },
+  "scripts": {
+    "test": "node --test \"test/**/*.test.mjs\"",
+    "prepublishOnly": "npm test"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "zedev",
+    "standards",
+    "cli"
+  ],
+  "license": "UNLICENSED",
+  "author": "ZeStudio",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/idrismikayil/zdev.git",
+    "directory": "cli"
+  },
+  "homepage": "https://dev.zestudio.az",
+  "bugs": {
+    "url": "https://github.com/idrismikayil/zdev/issues"
+  }
+}

package/src/args.js

@@ -0,0 +1,35 @@
+/**
+ * Əmr sətri ayırıcısı — asılılıqsız (yargs/commander gətirmirik, alət kiçikdir).
+ *
+ * Dəstəklənən formalar: `--flag`, `--key dəyər`, `--key=dəyər`, `-v`, `-h`, sərbəst arqument.
+ *
+ * ⚠️ **Tapılmış qüsur (2026-09-14):** əvvəl dəyər yoxlaması yalnız `--`-a baxırdı, ona görə
+ * `push --dry-run -v` yazanda `-v` **`--dry-run`-ın dəyəri kimi udulurdu** və verbose heç vaxt
+ * işə düşmürdü — məhsul sahibi 54 faylı siyahı gözləyib görmədi. İndi **istənilən** `-` ilə
+ * başlayan növbəti token dəyər sayılmır.
+ *
+ * Mənfi rəqəm dəyəri (`--limit -5`) bu qaydaya qurban gedir, amma belə bayrağımız yoxdur;
+ * lazım olanda `--limit=-5` forması işləyir.
+ */
+export function parse(argv) {
+  const args = [];
+  const flags = {};
+
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+
+    if (a === '-v') { flags.verbose = true; continue; }
+    if (a === '-h') { flags.help = true; continue; }
+    if (!a.startsWith('--')) { args.push(a); continue; }
+
+    const eq = a.indexOf('=');
+    if (eq > 0) { flags[a.slice(2, eq)] = a.slice(eq + 1); continue; }
+
+    const name = a.slice(2);
+    const next = argv[i + 1];
+    if (next && !next.startsWith('-')) { flags[name] = next; i++; }
+    else flags[name] = true;
+  }
+
+  return { args, flags };
+}

package/src/commands/login.js

@@ -0,0 +1,33 @@
+import { Mcp } from '../mcp.js';
+import { readGlobal, writeGlobal, normalizeServer, profileNameFor, GLOBAL_FILE } from '../config.js';
+import { ok, info, dim, maskKey } from '../ui.js';
+
+const DEFAULT_SERVER = 'https://dev.zestudio.az';
+
+/**
+ * `zedev login --key zedev_… [--server …] [--as ad]`
+ *
+ * Açar YOXLANIR və yalnız işlədiyi təsdiqlənəndən sonra yazılır: səhv yapışdırılmış
+ * açar diskdə qalsa, xəta növbəti əmrdə — başqa kontekstdə — çıxır və izahı çətinləşir.
+ */
+export async function login(flags) {
+  const key = flags.key;
+  if (!key) throw new Error('`--key zedev_…` lazımdır. Açarı platformada dəstin «CLI açarı» düyməsindən alırsan.');
+  if (!key.startsWith('zedev_')) throw new Error('Açar `zedev_` ilə başlamalıdır — yəqin natamam kopyalanıb.');
+
+  const server = normalizeServer(flags.server || process.env.ZEDEV_SERVER || DEFAULT_SERVER);
+  const name = flags.as || profileNameFor(server);
+
+  info(`${dim('Yoxlanılır:')} ${server}`);
+  const who = await new Mcp(server, key).call('project_info', {});
+
+  const cfg = await readGlobal();
+  cfg.profiles[name] = { server, key };
+  cfg.current = name;
+  await writeGlobal(cfg);
+
+  ok(`Açar yadda saxlanıldı — profil «${name}» (${maskKey(key)})`);
+  info(dim(`   ${GLOBAL_FILE()}`));
+  info('');
+  info(who.trim());
+}

package/src/commands/misc.js

@@ -0,0 +1,73 @@
+import path from 'node:path';
+import { writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { Mcp } from '../mcp.js';
+import { resolveContext, readGlobal, writeGlobal, LOCAL_NAME, normalizeServer } from '../config.js';
+import { collect, humanSize } from '../collect.js';
+import { ok, info, dim, bold, cyan, maskKey } from '../ui.js';
+
+/** `zedev status` — açar hara baxır, nə dərc olunub, qovluqda nə var. */
+export async function status(args, flags) {
+  const dir = path.resolve(args[0] || '.');
+  const ctx = await resolveContext({ dir, key: flags.key, server: flags.server, profile: flags.profile });
+
+  info(`${bold('Server')}   ${cyan(ctx.server)}`);
+  info(`${bold('Profil')}   ${ctx.profile} ${dim(maskKey(ctx.key))}`);
+  info(`${bold('Qovluq')}   ${dir}${ctx.localFile ? dim(`  (${path.basename(ctx.localFile)})`) : ''}`);
+  info('');
+
+  const info_ = await new Mcp(ctx.server, ctx.key).call('project_info', {});
+  info(info_.trim());
+
+  const { accepted, skipped, total } = await collect(dir);
+  info('');
+  info(`${bold('Yerli qovluq')}  ${accepted.length} fayl · ${humanSize(total)}${skipped.length ? dim(` · ${skipped.length} atılacaq`) : ''}`);
+}
+
+/** `zedev init` — qovluğa hədəf faylı yazır. Açar BURAYA yazılmır (repo-ya düşməsin). */
+export async function init(args, flags) {
+  const dir = path.resolve(args[0] || '.');
+  const file = path.join(dir, LOCAL_NAME);
+  if (existsSync(file) && !flags.force) throw new Error(`${LOCAL_NAME} artıq var. Əvəz etmək üçün --force.`);
+
+  const global = await readGlobal();
+  const profile = flags.profile || global.current;
+  if (!profile) throw new Error('Əvvəlcə `zedev login --key zedev_…` işlət.');
+
+  const data = { profile, publish: !!flags.publish };
+  await writeFile(file, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+  ok(`${LOCAL_NAME} yazıldı — profil «${profile}»${data.publish ? ', push dərc edir' : ''}`);
+  info(dim('Bu fayl sirr daşımır, komanda ilə paylaşıla bilər.'));
+}
+
+/** `zedev profiles` — hansı serverlərə açar var. */
+export async function profiles() {
+  const cfg = await readGlobal();
+  const names = Object.keys(cfg.profiles);
+  if (names.length === 0) { info(dim('Profil yoxdur. `zedev login --key zedev_…`')); return; }
+  for (const n of names) {
+    const p = cfg.profiles[n];
+    info(`${n === cfg.current ? bold(`* ${n}`) : `  ${n}`}  ${dim(p.server)}  ${dim(maskKey(p.key))}`);
+  }
+}
+
+/** `zedev logout [profil]` — açarı diskdən silir. */
+export async function logout(args) {
+  const cfg = await readGlobal();
+  const name = args[0] || cfg.current;
+  if (!name || !cfg.profiles[name]) throw new Error(`Profil tapılmadı: ${name || '(yoxdur)'}`);
+  delete cfg.profiles[name];
+  if (cfg.current === name) cfg.current = Object.keys(cfg.profiles)[0] ?? null;
+  await writeGlobal(cfg);
+  ok(`«${name}» silindi.`);
+}
+
+/** `zedev use <profil>` — cari profili dəyişir. */
+export async function use(args) {
+  const name = args[0];
+  const cfg = await readGlobal();
+  if (!name || !cfg.profiles[name]) throw new Error(`Profil tapılmadı: ${name || '(ad verilmədi)'}`);
+  cfg.current = name;
+  await writeGlobal(cfg);
+  ok(`Cari profil: ${name} ${dim(normalizeServer(cfg.profiles[name].server))}`);
+}

package/src/commands/push.js

@@ -0,0 +1,55 @@
+import path from 'node:path';
+import { Mcp } from '../mcp.js';
+import { resolveContext } from '../config.js';
+import { collect, toPayload, humanSize, MAX_TOTAL_BYTES } from '../collect.js';
+import { ok, info, warn, dim, bold, cyan, yellow } from '../ui.js';
+
+const REASON = { ignored: 'nəzərə alınmır', tooBig: 'çox böyük', invalid: 'yolu yaramır' };
+
+/**
+ * `zedev push [qovluq] [--publish] [--note "…"] [--delete-missing] [--dry-run]`
+ *
+ * Vebdəki yükləmə dialoqunun **eyni davranışı**: susqun halda heç nə silinmir, dərc
+ * ayrıca qərardır. Fərq yalnız girişdədir — brauzer əvəzinə qovluq.
+ */
+export async function push(args, flags) {
+  const dir = path.resolve(args[0] || '.');
+  const ctx = await resolveContext({ dir, key: flags.key, server: flags.server, profile: flags.profile });
+
+  const { accepted, skipped, total } = await collect(dir);
+  if (accepted.length === 0) throw new Error(`${dir} içində göndəriləsi fayl tapılmadı.`);
+  if (total > MAX_TOTAL_BYTES) {
+    throw new Error(`Ümumi həcm ${humanSize(total)} — limit ${humanSize(MAX_TOTAL_BYTES)}. Ağır qovluqları çıxar.`);
+  }
+
+  const deleteMissing = !!flags['delete-missing'];
+  const publish = flags.publish ?? ctx.local.publish ?? false;
+
+  info(`${bold(dir)}  ${dim('→')}  ${cyan(ctx.server)} ${dim(`(profil: ${ctx.profile})`)}`);
+  info(`${accepted.length} fayl · ${humanSize(total)}${skipped.length ? dim(` · ${skipped.length} atıldı`) : ''}`);
+  if (flags.verbose) {
+    for (const f of accepted) info(dim(`   ${f.path} (${humanSize(f.size)})`));
+    for (const s of skipped) info(dim(`   — ${s.path} (${REASON[s.reason] || s.reason})`));
+  }
+  // Silmə susqun deyil və həmişə səslə xəbərdarlıq edir — geri qaytarılmır.
+  if (deleteMissing) warn(yellow('--delete-missing: qovluqda olmayan fayllar qaralamadan SİLİNƏCƏK.'));
+
+  if (flags['dry-run']) {
+    info(dim('--dry-run: heç nə göndərilmədi.'));
+    return;
+  }
+
+  const mcp = new Mcp(ctx.server, ctx.key, { timeoutMs: 120_000 });
+  const payload = await toPayload(accepted);
+  const res = await mcp.call('standards_import', { files: payload, deleteMissing });
+  ok(res.trim());
+
+  if (!publish) {
+    info(dim('Qaralamaya yazıldı. Komandaya çatması üçün: `zedev push --publish` və ya platformada «Dərc et».'));
+    return;
+  }
+
+  const note = flags.note || `CLI · ${new Date().toISOString().slice(0, 16).replace('T', ' ')}`;
+  const pub = await mcp.call('standards_publish', { note });
+  ok(pub.trim());
+}

package/src/commands/watch.js

@@ -0,0 +1,77 @@
+import path from 'node:path';
+import { watch as fsWatch } from 'node:fs';
+import { Mcp } from '../mcp.js';
+import { resolveContext } from '../config.js';
+import { collect, toPayload, humanSize, IGNORED_DIRS, IGNORED_FILES } from '../collect.js';
+import { ok, info, fail, dim, bold, cyan } from '../ui.js';
+
+const DEBOUNCE_MS = 800;
+
+/**
+ * `zedev watch [qovluq] [--publish]`
+ *
+ * Redaktə → qaralama. **Dərc susqun halda yoxdur**: yazı prosesində hər saxlama komandaya
+ * yeni versiya kimi getsəydi, versiya jurnalı mənasını itirərdi (bu, `--publish` ilə
+ * şüurlu seçimdir).
+ *
+ * ⚠️ Tam ağac hər dəfə göndərilir — `standards_import` idempotentdir və fərqi server
+ * hesablayır. Fərqi klientdə hesablamaq (hash keşi) sürətli olardı, amma iki ayrı
+ * «həqiqət» yaradardı; qovluq ölçüsü bizdə kiçikdir (onlarla fayl).
+ */
+export async function watch(args, flags) {
+  const dir = path.resolve(args[0] || '.');
+  const ctx = await resolveContext({ dir, key: flags.key, server: flags.server, profile: flags.profile });
+  const mcp = new Mcp(ctx.server, ctx.key, { timeoutMs: 120_000 });
+
+  info(`${bold(dir)}  ${dim('→')}  ${cyan(ctx.server)} ${dim(`(profil: ${ctx.profile})`)}`);
+  info(dim('İzlənir. Dayandırmaq: Ctrl+C'));
+
+  let timer = null;
+  let running = false;
+  let again = false;
+
+  const send = async () => {
+    if (running) { again = true; return; }
+    running = true;
+    try {
+      const { accepted, total } = await collect(dir);
+      if (accepted.length === 0) { info(dim('fayl yoxdur')); return; }
+      const res = await mcp.call('standards_import', { files: await toPayload(accepted), deleteMissing: false });
+      ok(`${new Date().toLocaleTimeString()} · ${res.trim().split('\n')[0]} ${dim(`(${accepted.length} fayl · ${humanSize(total)})`)}`);
+      if (flags.publish) {
+        const pub = await mcp.call('standards_publish', { note: flags.note || 'CLI watch' });
+        ok(pub.trim().split('\n')[0]);
+      }
+    } catch (e) {
+      // İzləmə davam edir: şəbəkə qırılması və ya müvəqqəti server xətası seansı öldürməsin.
+      fail(e.message);
+    } finally {
+      running = false;
+      if (again) { again = false; send(); }
+    }
+  };
+
+  const interesting = (file) => {
+    if (!file) return true;
+    const segs = String(file).replace(/\\/g, '/').split('/');
+    if (segs.some((s) => IGNORED_DIRS.has(s))) return false;
+    return !IGNORED_FILES.has(segs[segs.length - 1]);
+  };
+
+  let watcher;
+  try {
+    watcher = fsWatch(dir, { recursive: true }, (_event, file) => {
+      if (!interesting(file)) return;
+      clearTimeout(timer);
+      timer = setTimeout(send, DEBOUNCE_MS);
+    });
+  } catch (e) {
+    // Köhnə Linux nüvələrində `recursive` dəstəklənmir — səbəbi açıq deyirik.
+    throw new Error(`Qovluq izlənə bilmədi: ${e.message}. Bu platformada \`zedev push\` işlət.`);
+  }
+
+  await send(); // ilk vəziyyət dərhal göndərilir — "işləyir?" sualı qalmasın
+
+  process.on('SIGINT', () => { watcher.close(); info(dim('\nDayandırıldı.')); process.exit(0); });
+  await new Promise(() => {}); // Ctrl+C-yə qədər
+}

package/src/config.js

@@ -0,0 +1,99 @@
+import { readFile, writeFile, mkdir, chmod } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+
+/**
+ * Konfiqurasiya İKİ yerə bölünür və bu bölgü təhlükəsizlik qərarıdır:
+ *
+ * · **Açar** — `~/.zedev/config.json` (istifadəçinin ev qovluğu, 0600).
+ *   Repo qovluğuna heç vaxt yazılmır: orada olsaydı, ilk `git add .` onu commit edərdi.
+ * · **Hədəf** — qovluqdakı `.zedev.json` (server + profil adı).
+ *   Bu, komanda ilə paylaşıla bilər, çünki sirr daşımır.
+ *
+ * Üstünlük sırası: bayraq → mühit dəyişəni → `.zedev.json` → qlobal konfiq.
+ */
+
+export const GLOBAL_DIR = () => process.env.ZEDEV_HOME || path.join(homedir(), '.zedev');
+export const GLOBAL_FILE = () => path.join(GLOBAL_DIR(), 'config.json');
+export const LOCAL_NAME = '.zedev.json';
+
+const readJson = async (file) => {
+  try { return JSON.parse(await readFile(file, 'utf8')); }
+  catch (e) {
+    if (e.code === 'ENOENT') return null;
+    throw new Error(`${file} oxunmadı: ${e.message}`);
+  }
+};
+
+export async function readGlobal() {
+  const raw = await readJson(GLOBAL_FILE());
+  if (!raw) return { profiles: {}, current: null };
+  return { profiles: raw.profiles ?? {}, current: raw.current ?? null };
+}
+
+export async function writeGlobal(cfg) {
+  await mkdir(GLOBAL_DIR(), { recursive: true });
+  await writeFile(GLOBAL_FILE(), `${JSON.stringify(cfg, null, 2)}\n`, 'utf8');
+  // Windows-da POSIX rejimi yoxdur — səssiz keçirik, faylın özü istifadəçi profilindədir.
+  try { await chmod(GLOBAL_FILE(), 0o600); } catch { /* Windows */ }
+}
+
+/** `.zedev.json`-u qovluqdan yuxarı doğru axtarır — alt qovluqdan da `zedev push` işləsin. */
+export async function findLocal(startDir) {
+  let dir = path.resolve(startDir);
+  for (;;) {
+    const file = path.join(dir, LOCAL_NAME);
+    if (existsSync(file)) return { file, data: (await readJson(file)) ?? {} };
+    const up = path.dirname(dir);
+    if (up === dir) return null;
+    dir = up;
+  }
+}
+
+/** Serverin sonundakı `/` və təsadüfi `/api/mcp` quyruğu atılır — ikisi də tez-tez yapışdırılır. */
+export function normalizeServer(raw) {
+  if (!raw) return null;
+  let s = String(raw).trim().replace(/\/+$/, '');
+  if (!/^https?:\/\//i.test(s)) s = `https://${s}`;
+  return s.replace(/\/api\/mcp$/i, '');
+}
+
+/**
+ * Əmrin işləyəcəyi kontekst. Açar tapılmasa danışan xəta atılır — CLI-ın ən çox
+ * rast gəlinən ilk təcrübəsi məhz budur.
+ */
+export async function resolveContext({ dir = process.cwd(), key, server, profile } = {}) {
+  const local = await findLocal(dir);
+  const global = await readGlobal();
+
+  const name = profile || process.env.ZEDEV_PROFILE || local?.data?.profile || global.current;
+  const saved = (name && global.profiles[name]) || null;
+
+  const finalServer = normalizeServer(
+    server || process.env.ZEDEV_SERVER || local?.data?.server || saved?.server,
+  );
+  const finalKey = key || process.env.ZEDEV_KEY || saved?.key;
+
+  if (!finalKey) {
+    throw new Error(
+      'Açar yoxdur. Platformada dəstin «CLI açarı» düyməsindən açar al, sonra:\n'
+      + '  zedev login --key zedev_…',
+    );
+  }
+  if (!finalServer) throw new Error('Server bilinmir. `zedev login --key … --server https://…` yaz.');
+
+  return {
+    server: finalServer,
+    key: finalKey,
+    profile: name || 'default',
+    localFile: local?.file ?? null,
+    local: local?.data ?? {},
+  };
+}
+
+/** Profil adı serverin host hissəsindən götürülür: `dev.zestudio.az` → `dev`. */
+export function profileNameFor(server) {
+  try { return new URL(server).hostname.split('.')[0] || 'default'; }
+  catch { return 'default'; }
+}

package/src/mcp.js

@@ -0,0 +1,82 @@
+/**
+ * ZEDEV MCP klienti — asılılıqsız, `fetch` üzərində.
+ *
+ * Server **stateless HTTP** transportu işlədir: hər sorğu müstəqildir, ona görə
+ * alət çağırışından əvvəl hər dəfə `initialize` gedir (sessiya saxlanmır).
+ * Cavab ya JSON, ya da SSE (`data: {...}`) olur — hər ikisi oxunur.
+ */
+
+const RPC = '2.0';
+
+export class McpError extends Error {}
+
+export class Mcp {
+  constructor(server, key, { timeoutMs = 60_000 } = {}) {
+    this.url = `${server}/api/mcp`;
+    this.key = key;
+    this.timeoutMs = timeoutMs;
+    this.id = 0;
+  }
+
+  async #send(method, params) {
+    const body = JSON.stringify({ jsonrpc: RPC, id: ++this.id, method, params: params ?? {} });
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), this.timeoutMs);
+    let res;
+    try {
+      res = await fetch(this.url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          // Server SSE qaytara bilər — hər ikisini qəbul etdiyimizi bildiririk.
+          Accept: 'application/json, text/event-stream',
+          Authorization: `Bearer ${this.key}`,
+        },
+        body,
+        signal: ac.signal,
+      });
+    } catch (e) {
+      if (e.name === 'AbortError') throw new McpError(`Server ${this.timeoutMs / 1000}s cavab vermədi: ${this.url}`);
+      throw new McpError(`Serverə qoşulmaq olmadı (${this.url}): ${e.message}`);
+    } finally {
+      clearTimeout(timer);
+    }
+
+    const text = await res.text();
+    if (res.status === 401 || res.status === 403) {
+      throw new McpError('Açar qəbul olunmadı (401/403). Ləğv edilib və ya başqa serverə aiddir.');
+    }
+    if (!res.ok && !text) throw new McpError(`Server ${res.status} qaytardı.`);
+
+    const line = text.split('\n').find((l) => l.startsWith('data:'));
+    let json;
+    try { json = JSON.parse(line ? line.slice(5).trim() : text); }
+    catch { throw new McpError(`Cavab oxunmadı (${res.status}): ${text.slice(0, 200)}`); }
+
+    if (json.error) throw new McpError(json.error.message || JSON.stringify(json.error));
+    return json.result;
+  }
+
+  async #init() {
+    await this.#send('initialize', {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: { name: 'zedev-cli', version: '0.1.0' },
+    });
+  }
+
+  /** Alət çağırışı. Alət səviyyəsindəki xəta `isError` ilə gəlir — onu da atırıq. */
+  async call(name, args = {}) {
+    await this.#init();
+    const result = await this.#send('tools/call', { name, arguments: args });
+    const text = (result?.content ?? []).map((c) => c.text).filter(Boolean).join('\n');
+    if (result?.isError) throw new McpError(text || `\`${name}\` xəta qaytardı.`);
+    return text;
+  }
+
+  async tools() {
+    await this.#init();
+    const result = await this.#send('tools/list', {});
+    return (result?.tools ?? []).map((x) => x.name);
+  }
+}

package/src/ui.js

@@ -0,0 +1,19 @@
+/** Terminal çıxışı — asılılıqsız. Rəng yalnız əsl terminalda (boru/CI-da düz mətn). */
+
+const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+const wrap = (code) => (s) => (useColor ? `[${code}m${s}` : String(s));
+
+export const bold = wrap('1');
+export const dim = wrap('2');
+export const green = wrap('32');
+export const yellow = wrap('33');
+export const red = wrap('31');
+export const cyan = wrap('36');
+
+export const info = (msg) => console.log(msg);
+export const ok = (msg) => console.log(`${green('✓')} ${msg}`);
+export const warn = (msg) => console.log(`${yellow('!')} ${msg}`);
+export const fail = (msg) => console.error(`${red('✗')} ${msg}`);
+
+/** Açar heç vaxt tam çap olunmur — terminal jurnalı və ekran görüntüsü sızma yoludur. */
+export const maskKey = (key) => (key && key.length > 12 ? `${key.slice(0, 10)}…${key.slice(-4)}` : '…');