@rbinar/dev-kit 1.0.0

package/lib/commands/status.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { isInitialized, readVersion } = require('../installer');
+const { TARGET_AGENTS_DIR, TARGET_PROMPTS_DIR } = require('../constants');
+
+async function status() {
+  const cwd = process.cwd();
+  const cliVersion = require('../../package.json').version;
+
+  if (!isInitialized(cwd)) {
+    console.log('blink-dev kurulu değil. Kurulum için: blink-dev init --key=SIFRE');
+    return;
+  }
+
+  const versionInfo = readVersion(cwd);
+  const bundleVersion = versionInfo ? versionInfo.version : '—';
+  const installedAt = versionInfo ? versionInfo.installedAt : '—';
+  const updatedAt = versionInfo ? versionInfo.updatedAt : '—';
+
+  const agentsDir = path.join(cwd, TARGET_AGENTS_DIR);
+  let agentCount = 0;
+  try {
+    agentCount = fs.readdirSync(agentsDir).filter(f => f.endsWith('.agent.md')).length;
+  } catch (_) {
+    // dizin yoksa 0
+  }
+
+  const promptsDir = path.join(cwd, TARGET_PROMPTS_DIR);
+  let promptCount = 0;
+  try {
+    promptCount = fs.readdirSync(promptsDir).filter(f => f.endsWith('.prompt.md')).length;
+  } catch (_) {
+    // dizin yoksa 0
+  }
+
+  console.log(`blink-dev durum raporu
+══════════════════════
+
+CLI versiyonu:     ${cliVersion}
+Bundle versiyonu:  ${bundleVersion}
+Kurulum tarihi:    ${installedAt}
+Son güncelleme:    ${updatedAt}
+
+Kurulu ajanlar:    ${agentCount}
+Kurulu promptlar:  ${promptCount}`);
+}
+
+module.exports = status;

package/lib/commands/update.js

@@ -0,0 +1,186 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const zlib = require('node:zlib');
+const tar = require('tar');
+
+const { decrypt } = require('../crypto');
+const {
+  installFiles,
+  mergeCopilotInstructions,
+  isInitialized,
+  writeVersion,
+  readVersion,
+  createBackup,
+  restoreBackup,
+} = require('../installer');
+const { BUNDLE_PATH, TARGET_AGENTS_DIR, TARGET_PROMPTS_DIR } = require('../constants');
+
+/**
+ * Decrypt edilmiş tarball buffer'ını geçici dizine açıp dosya haritası döndürür.
+ * copilot-instructions.md içeriğini ayrı olarak döndürür.
+ */
+function extractBundle(decryptedBuffer) {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'blink-dev-'));
+  const tmpTarball = path.join(tmpDir, 'bundle.tar.gz');
+
+  try {
+    fs.writeFileSync(tmpTarball, decryptedBuffer);
+    tar.x({ file: tmpTarball, cwd: tmpDir, sync: true });
+
+    const fileMap = new Map();
+    let copilotInstructions = null;
+
+    function walk(dir, prefix) {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+
+        if (entry.isDirectory()) {
+          walk(fullPath, relPath);
+        } else if (entry.isFile()) {
+          const content = fs.readFileSync(fullPath);
+
+          if (entry.name === 'copilot-instructions.md') {
+            copilotInstructions = content.toString('utf8');
+          } else if (relPath.startsWith('agents/')) {
+            const targetPath = path.join(TARGET_AGENTS_DIR, relPath.slice('agents/'.length));
+            fileMap.set(targetPath, content);
+          } else if (relPath.startsWith('prompts/')) {
+            const targetPath = path.join(TARGET_PROMPTS_DIR, relPath.slice('prompts/'.length));
+            fileMap.set(targetPath, content);
+          }
+        }
+      }
+    }
+
+    // Tarball içindeki kök dizini bul
+    const extracted = fs.readdirSync(tmpDir).filter(
+      (f) => f !== 'bundle.tar.gz' && fs.statSync(path.join(tmpDir, f)).isDirectory()
+    );
+    const root = extracted.length === 1 ? path.join(tmpDir, extracted[0]) : tmpDir;
+
+    walk(root, '');
+
+    return { fileMap, copilotInstructions };
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Dosya haritasını mevcut kurulumla karşılaştırır.
+ */
+function diffFiles(fileMap, cwd) {
+  const updated = [];
+  const added = [];
+  const unchanged = [];
+
+  for (const [relPath, content] of fileMap) {
+    const target = path.join(cwd, relPath);
+
+    if (!fs.existsSync(target)) {
+      added.push(relPath);
+      continue;
+    }
+
+    const existing = fs.readFileSync(target);
+    if (Buffer.compare(existing, content) === 0) {
+      unchanged.push(relPath);
+    } else {
+      updated.push(relPath);
+    }
+  }
+
+  return { updated, added, unchanged };
+}
+
+/**
+ * blink-dev update --key=SIFRE handler'ı
+ */
+async function update({ key, dryRun }) {
+  const cwd = process.cwd();
+
+  // 1. Kurulum kontrolü
+  if (!isInitialized(cwd)) {
+    console.error('Kurulum bulunamadı. Önce `blink-dev init --key=SIFRE` çalıştırın.');
+    process.exit(1);
+  }
+
+  // 2. Mevcut versiyon
+  const currentVersion = readVersion(cwd);
+  if (currentVersion) {
+    console.log(`Mevcut versiyon: ${currentVersion.version} (kurulum: ${currentVersion.installedAt})`);
+  }
+
+  // 3. Bundle oku + decrypt
+  const encBuffer = fs.readFileSync(BUNDLE_PATH);
+  const decryptedBuffer = decrypt(encBuffer, key);
+
+  // 4. Tarball extract
+  const { fileMap, copilotInstructions } = extractBundle(decryptedBuffer);
+
+  // 5. Dry-run
+  const { updated, added, unchanged } = diffFiles(fileMap, cwd);
+
+  if (dryRun) {
+    console.log('\n🔍 Dry-run sonucu:\n');
+    if (updated.length) {
+      console.log('Güncellenecek:');
+      updated.forEach((f) => console.log(`  📝 ${f}`));
+    }
+    if (added.length) {
+      console.log('Yeni:');
+      added.forEach((f) => console.log(`  ➕ ${f}`));
+    }
+    if (unchanged.length) {
+      console.log('Değişiklik yok:');
+      unchanged.forEach((f) => console.log(`  ⏩ ${f}`));
+    }
+    return;
+  }
+
+  // 6. Backup al
+  const backupDir = createBackup(cwd);
+
+  try {
+    // 7. Dosyaları güncelle (force: true — mevcut dosyaları güncelliyoruz)
+    installFiles(fileMap, cwd, { force: true });
+
+    // 8. Copilot instructions merge
+    if (copilotInstructions) {
+      mergeCopilotInstructions(copilotInstructions, cwd);
+    }
+
+    // 9. Versiyon güncelle
+    const newVersion = require('../../package.json').version;
+    writeVersion(cwd, newVersion);
+
+    // 10. Backup temizle
+    fs.rmSync(backupDir, { recursive: true, force: true });
+
+    // 12. Başarı mesajı
+    const prevVersion = currentVersion ? currentVersion.version : 'bilinmiyor';
+    console.log(`\n✅ blink-dev başarıyla güncellendi!\n`);
+    console.log(`📁 Güncellenen: ${updated.length}`);
+    console.log(`➕ Yeni eklenen: ${added.length}`);
+    console.log(`⏩ Değişmeyen: ${unchanged.length}`);
+    console.log(`\nÖnceki versiyon: ${prevVersion}`);
+    console.log(`Yeni versiyon: ${newVersion}`);
+  } catch (err) {
+    // 11. Hata durumu — backup'tan geri yükle
+    console.error('Güncelleme sırasında hata oluştu, backup\'tan geri yükleniyor...');
+    try {
+      restoreBackup(cwd);
+      console.error('Backup başarıyla geri yüklendi.');
+    } catch (restoreErr) {
+      console.error('Backup geri yükleme başarısız:', restoreErr.message);
+    }
+    throw err;
+  }
+}
+
+module.exports = update;

package/lib/constants.js

@@ -0,0 +1,120 @@
+'use strict';
+
+const path = require('node:path');
+
+// Target directories in user's project
+const TARGET_AGENTS_DIR = '.github/agents';
+const TARGET_PROMPTS_DIR = '.github/prompts';
+const TARGET_BLINK_DIR = '.blink';
+const TARGET_INSTRUCTIONS = '.github/copilot-instructions.md';
+
+// CLI internal files
+const VERSION_FILE = '.blink-dev-version';
+const BACKUP_DIR = '.blink-dev-backup';
+const TMP_DIR = '.blink-dev-tmp';
+const BUNDLE_PATH = path.join(__dirname, '..', 'bundle', 'agents-bundle.enc');
+
+// Section markers for copilot-instructions.md merge
+const MARKER_START = '<!-- BLINK-DEV-KIT:START — bu bölümü elle düzenlemeyin -->';
+const MARKER_END = '<!-- BLINK-DEV-KIT:END -->';
+
+// Encryption parameters
+const PBKDF2_ITERATIONS = 100_000;
+const PBKDF2_KEYLEN = 32; // 256 bits
+const PBKDF2_DIGEST = 'sha256';
+const CIPHER_ALGORITHM = 'aes-256-cbc';
+const SALT_LENGTH = 16;
+const IV_LENGTH = 16;
+const HASH_LENGTH = 32; // SHA-256
+
+// Scaffold templates for .blink/ directory
+const SCAFFOLD_FILES = {
+  'architecture.md': `<!-- Generated by blink-dev init -->
+
+# Architecture
+
+## Module Map
+
+| Path | Purpose |
+|---|---|
+| | |
+
+## Key Dependencies
+
+| Dependency | Role |
+|---|---|
+| | |
+`,
+  'conventions.md': `<!-- Generated by blink-dev init -->
+
+# Conventions
+
+## Code Style
+
+## Naming
+
+## Error Handling
+`,
+  'stack.md': `<!-- Generated by blink-dev init -->
+
+# Stack
+
+## Language
+
+## Framework
+
+## Package Manager
+
+## Key Dependencies
+`,
+  'testing.md': `<!-- Generated by blink-dev init -->
+
+# Testing
+
+## Framework
+
+## Strategy
+
+## Coverage
+`,
+};
+
+// Expected agent files (for doctor checks)
+const EXPECTED_AGENTS = [
+  'Analyst.agent.md',
+  'Brainstorm.agent.md',
+  'Coordinator.agent.md',
+  'Critic.agent.md',
+  'Debugger.agent.md',
+  'Guardian.agent.md',
+  'Initializer.agent.md',
+  'Ops.agent.md',
+  'Planner.agent.md',
+  'Reviewer.agent.md',
+  'Scribe.agent.md',
+  'Security.agent.md',
+  'Shipper.agent.md',
+  'Triage.agent.md',
+];
+
+module.exports = {
+  TARGET_AGENTS_DIR,
+  TARGET_PROMPTS_DIR,
+  TARGET_BLINK_DIR,
+  TARGET_INSTRUCTIONS,
+  VERSION_FILE,
+  BACKUP_DIR,
+  TMP_DIR,
+  BUNDLE_PATH,
+  MARKER_START,
+  MARKER_END,
+  PBKDF2_ITERATIONS,
+  PBKDF2_KEYLEN,
+  PBKDF2_DIGEST,
+  CIPHER_ALGORITHM,
+  SALT_LENGTH,
+  IV_LENGTH,
+  HASH_LENGTH,
+  SCAFFOLD_FILES,
+  EXPECTED_AGENTS,
+};

package/lib/crypto.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const crypto = require('node:crypto');
+
+const ALGORITHM = 'aes-256-cbc';
+const PBKDF2_ITERATIONS = 100000;
+const PBKDF2_DIGEST = 'sha256';
+const KEY_LENGTH = 32;
+const SALT_LENGTH = 16;
+const IV_LENGTH = 16;
+const HASH_LENGTH = 32;
+
+/**
+ * @param {Buffer} buffer
+ * @param {string} password
+ * @returns {Buffer}
+ */
+function encrypt(buffer, password) {
+  const salt = crypto.randomBytes(SALT_LENGTH);
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const key = crypto.pbkdf2Sync(password, salt, PBKDF2_ITERATIONS, KEY_LENGTH, PBKDF2_DIGEST);
+
+  const hash = crypto.createHash('sha256').update(buffer).digest();
+  const plainWithHash = Buffer.concat([hash, buffer]);
+
+  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+  const encrypted = Buffer.concat([cipher.update(plainWithHash), cipher.final()]);
+
+  return Buffer.concat([salt, iv, encrypted]);
+}
+
+/**
+ * @param {Buffer} encBuffer
+ * @param {string} password
+ * @returns {Buffer}
+ */
+function decrypt(encBuffer, password) {
+  const salt = encBuffer.subarray(0, SALT_LENGTH);
+  const iv = encBuffer.subarray(SALT_LENGTH, SALT_LENGTH + IV_LENGTH);
+  const ciphertext = encBuffer.subarray(SALT_LENGTH + IV_LENGTH);
+
+  const key = crypto.pbkdf2Sync(password, salt, PBKDF2_ITERATIONS, KEY_LENGTH, PBKDF2_DIGEST);
+
+  let decrypted;
+  try {
+    const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+    decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+  } catch (_) {
+    throw new Error('Geçersiz anahtar veya bozuk bundle');
+  }
+
+  const storedHash = decrypted.subarray(0, HASH_LENGTH);
+  const originalData = decrypted.subarray(HASH_LENGTH);
+
+  const computedHash = crypto.createHash('sha256').update(originalData).digest();
+
+  if (!crypto.timingSafeEqual(storedHash, computedHash)) {
+    throw new Error('Geçersiz anahtar veya bozuk bundle');
+  }
+
+  return originalData;
+}
+
+module.exports = { encrypt, decrypt };

package/lib/installer.js

@@ -0,0 +1,234 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const constants = require('./constants');
+
+/**
+ * Dosyaları atomik olarak hedefe yazar.
+ */
+function installFiles(fileMap, cwd, options = {}) {
+  const { dryRun = false, force = false } = options;
+  const installed = [];
+  const skipped = [];
+  const errors = [];
+
+  if (dryRun) {
+    for (const [relPath] of fileMap) {
+      const target = path.join(cwd, relPath);
+      if (!force && fs.existsSync(target)) {
+        skipped.push(relPath);
+      } else {
+        installed.push(relPath);
+      }
+    }
+    return { installed, skipped, errors };
+  }
+
+  const tmpDir = path.join(cwd, constants.TMP_DIR);
+
+  try {
+    // 1. Geçici dizin oluştur
+    fs.mkdirSync(tmpDir, { recursive: true });
+
+    // 2. Tüm dosyaları geçici dizine yaz
+    for (const [relPath, content] of fileMap) {
+      const tmpTarget = path.join(tmpDir, relPath);
+      fs.mkdirSync(path.dirname(tmpTarget), { recursive: true });
+      fs.writeFileSync(tmpTarget, content);
+    }
+
+    // 3. Geçici dizinden hedef dizine kopyala
+    for (const [relPath] of fileMap) {
+      const source = path.join(tmpDir, relPath);
+      const target = path.join(cwd, relPath);
+
+      if (!force && fs.existsSync(target)) {
+        skipped.push(relPath);
+        continue;
+      }
+
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.cpSync(source, target);
+      installed.push(relPath);
+    }
+  } catch (err) {
+    errors.push(err.message);
+    throw err;
+  } finally {
+    // 4. Geçici dizini temizle
+    if (fs.existsSync(tmpDir)) {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  }
+
+  return { installed, skipped, errors };
+}
+
+/**
+ * copilot-instructions.md dosyasını section marker'larla günceller.
+ */
+function mergeCopilotInstructions(content, cwd) {
+  const targetPath = path.join(cwd, constants.TARGET_INSTRUCTIONS);
+  const targetDir = path.dirname(targetPath);
+
+  // .github/ dizini yoksa oluştur
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  const markerBlock = `${constants.MARKER_START}\n${content}\n${constants.MARKER_END}`;
+
+  // Dosya yoksa: marker block olarak oluştur
+  if (!fs.existsSync(targetPath)) {
+    fs.writeFileSync(targetPath, markerBlock + '\n');
+    return;
+  }
+
+  const existing = fs.readFileSync(targetPath, 'utf8');
+
+  // Dosya varsa ve marker'lar varsa: arasını değiştir
+  const startIdx = existing.indexOf(constants.MARKER_START);
+  const endIdx = existing.indexOf(constants.MARKER_END);
+
+  if (startIdx !== -1 && endIdx !== -1) {
+    const before = existing.slice(0, startIdx);
+    const after = existing.slice(endIdx + constants.MARKER_END.length);
+    fs.writeFileSync(targetPath, before + markerBlock + after);
+    return;
+  }
+
+  // Dosya varsa ama marker yoksa: başına ekle
+  fs.writeFileSync(targetPath, markerBlock + '\n\n' + existing);
+}
+
+/**
+ * .blink/ dizinine minimum scaffold şablonları yazar. Mevcut dosyaları ezmez.
+ */
+function createScaffold(cwd) {
+  const created = [];
+  const skipped = [];
+
+  const blinkDir = path.join(cwd, constants.TARGET_BLINK_DIR);
+  fs.mkdirSync(blinkDir, { recursive: true });
+
+  for (const [fileName, content] of Object.entries(constants.SCAFFOLD_FILES)) {
+    const filePath = path.join(blinkDir, fileName);
+
+    if (fs.existsSync(filePath)) {
+      skipped.push(fileName);
+      continue;
+    }
+
+    fs.writeFileSync(filePath, content);
+    created.push(fileName);
+  }
+
+  return { created, skipped };
+}
+
+/**
+ * Kurulumun mevcut olup olmadığını kontrol eder.
+ */
+function isInitialized(cwd) {
+  return fs.existsSync(path.join(cwd, constants.VERSION_FILE));
+}
+
+/**
+ * Versiyon dosyasını yazar.
+ */
+function writeVersion(cwd, version) {
+  const filePath = path.join(cwd, constants.VERSION_FILE);
+  const now = new Date().toISOString();
+  let data;
+
+  if (fs.existsSync(filePath)) {
+    const existing = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    data = {
+      version,
+      installedAt: existing.installedAt,
+      updatedAt: now,
+    };
+  } else {
+    data = {
+      version,
+      installedAt: now,
+      updatedAt: now,
+    };
+  }
+
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n');
+}
+
+/**
+ * Versiyon dosyasını okur.
+ */
+function readVersion(cwd) {
+  const filePath = path.join(cwd, constants.VERSION_FILE);
+
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+/**
+ * Mevcut kurulumun backup'ını alır.
+ */
+function createBackup(cwd) {
+  const backupDir = path.join(cwd, constants.BACKUP_DIR);
+  fs.mkdirSync(backupDir, { recursive: true });
+
+  const sources = [
+    constants.TARGET_AGENTS_DIR,
+    constants.TARGET_PROMPTS_DIR,
+  ];
+
+  for (const relDir of sources) {
+    const srcDir = path.join(cwd, relDir);
+    if (!fs.existsSync(srcDir)) continue;
+
+    const destDir = path.join(backupDir, relDir);
+    fs.mkdirSync(destDir, { recursive: true });
+    fs.cpSync(srcDir, destDir, { recursive: true });
+  }
+
+  return backupDir;
+}
+
+/**
+ * Backup'tan geri yükle.
+ */
+function restoreBackup(cwd) {
+  const backupDir = path.join(cwd, constants.BACKUP_DIR);
+
+  if (!fs.existsSync(backupDir)) {
+    throw new Error('Backup dizini bulunamadı: ' + backupDir);
+  }
+
+  const targets = [
+    constants.TARGET_AGENTS_DIR,
+    constants.TARGET_PROMPTS_DIR,
+  ];
+
+  for (const relDir of targets) {
+    const srcDir = path.join(backupDir, relDir);
+    if (!fs.existsSync(srcDir)) continue;
+
+    const destDir = path.join(cwd, relDir);
+    fs.mkdirSync(destDir, { recursive: true });
+    fs.cpSync(srcDir, destDir, { recursive: true });
+  }
+
+  fs.rmSync(backupDir, { recursive: true, force: true });
+}
+
+module.exports = {
+  installFiles,
+  mergeCopilotInstructions,
+  createScaffold,
+  isInitialized,
+  writeVersion,
+  readVersion,
+  createBackup,
+  restoreBackup,
+};