social-agent-cli 1.0.0 → 1.0.2

package/ai/knowledge.ts

@@ -0,0 +1,47 @@
+import { readFileSync, writeFileSync, existsSync, appendFileSync } from "node:fs";
+import { join } from "node:path";
+import { PATHS } from "../core/config.js";
+
+const KNOWLEDGE_DIR = join(PATHS.root, "knowledge");
+
+/**
+ * Platform bilgisini oku.
+ * knowledge/PLATFORM.md dosyasından gelir (kullanıcı tarafından yazılır).
+ * AI sadece okur, yazmaz.
+ */
+export function getPlatformKnowledge(platform: string): string {
+  const mainPath = join(KNOWLEDGE_DIR, `${platform}.md`);
+  const learnedPath = join(KNOWLEDGE_DIR, `${platform}_learned.md`);
+
+  let knowledge = "";
+
+  // Ana bilgi dosyası (kullanıcı tarafından yazılır)
+  if (existsSync(mainPath)) {
+    knowledge += readFileSync(mainPath, "utf-8");
+  } else {
+    console.log(`[knowledge] ${platform}.md bulunamadı. knowledge/${platform}.md dosyasını oluştur.`);
+  }
+
+  // AI'ın işlem sırasında öğrendikleri
+  if (existsSync(learnedPath)) {
+    knowledge += "\n\n## AI Tarafından Öğrenilen Bilgiler\n" + readFileSync(learnedPath, "utf-8");
+  }
+
+  return knowledge;
+}
+
+/**
+ * AI işlem sırasında yeni bir şey öğrendiğinde bunu kaydeder.
+ * Ana knowledge dosyasına dokunmaz, ayrı _learned.md dosyasına yazar.
+ */
+export function addLearnedKnowledge(platform: string, info: string): void {
+  const { mkdirSync } = require("node:fs");
+  mkdirSync(KNOWLEDGE_DIR, { recursive: true });
+
+  const learnedPath = join(KNOWLEDGE_DIR, `${platform}_learned.md`);
+  const timestamp = new Date().toISOString().split("T")[0];
+  const entry = `\n### ${timestamp}\n${info}\n`;
+
+  appendFileSync(learnedPath, entry);
+  console.log(`[knowledge] ${platform} yeni bilgi eklendi: ${info.substring(0, 80)}...`);
+}

package/ai/mapper.ts

@@ -0,0 +1,348 @@
+import { spawn } from "node:child_process";
+import { readFileSync, writeFileSync, existsSync, mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { PATHS } from "../core/config.js";
+import type { SelectorMap } from "../core/types.js";
+
+// ── JSON Schemas ─────────────────────────────────────────────
+
+const SELECTOR_MAP_SCHEMA = JSON.stringify({
+  type: "object",
+  properties: {
+    platform: { type: "string" },
+    action: { type: "string" },
+    description: { type: "string" },
+    version: { type: "number" },
+    lastUpdated: { type: "string" },
+    parameters: { type: "array", items: { type: "string" } },
+    steps: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          action: { type: "string", enum: ["click", "type", "wait", "keypress", "goto"] },
+          description: { type: "string" },
+          selector: { type: "string" },
+          value: { type: "string" },
+          key: { type: "string" },
+          url: { type: "string" },
+          waitMs: { type: "number" },
+          fallbackSelectors: { type: "array", items: { type: "string" } },
+        },
+        required: ["action", "description"],
+      },
+    },
+  },
+  required: ["platform", "version", "steps"],
+});
+
+const HEAL_SCHEMA = JSON.stringify({
+  type: "object",
+  properties: {
+    selector: { type: "string" },
+    fallbackSelectors: { type: "array", items: { type: "string" } },
+    explanation: { type: "string" },
+  },
+  required: ["selector", "fallbackSelectors", "explanation"],
+});
+
+// ── Claude -p Wrapper ────────────────────────────────────────
+
+interface ClaudeOptions {
+  prompt: string;
+  jsonSchema?: string;
+  imagePath?: string;
+  model?: string;
+  effort?: string;
+  stream?: boolean;
+}
+
+function claude(opts: ClaudeOptions): Promise<any> {
+  const { prompt, jsonSchema, imagePath, model = "opus", effort = "low", stream = true } = opts;
+
+  const tmpDir = mkdtempSync(join(tmpdir(), "social-agent-"));
+  const promptFile = join(tmpDir, "prompt.txt");
+  writeFileSync(promptFile, prompt);
+
+  return new Promise((resolve, reject) => {
+    let cmd: string;
+    const base = `claude -p --model ${model} --effort ${effort} --max-turns 3 --tools ""`;
+
+    // Screenshot varsa prompt'a dosya yolunu ekle, Claude Code dosyayı okuyabilir
+    if (imagePath && existsSync(imagePath)) {
+      writeFileSync(promptFile, `Screenshot: ${imagePath}\n\n${prompt}`);
+    }
+    cmd = `cat '${promptFile}' | ${base}`;
+    if (jsonSchema) cmd += ` --output-format json --json-schema '${jsonSchema}'`;
+
+    const proc = spawn("bash", ["-c", cmd], {
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    proc.stdout.on("data", (chunk: Buffer) => {
+      const text = chunk.toString();
+      stdout += text;
+      if (stream) process.stdout.write(text);
+    });
+
+    proc.stderr.on("data", (chunk: Buffer) => {
+      stderr += chunk.toString();
+    });
+
+    proc.on("close", (code) => {
+      rmSync(tmpDir, { recursive: true, force: true });
+      if (stream) process.stdout.write("\n");
+
+      const output = stdout.trim();
+
+      if (jsonSchema) {
+        try {
+          const parsed = JSON.parse(output);
+
+          // structured_output alanı varsa ve dolu ise
+          if (parsed.structured_output && parsed.structured_output.steps) {
+            resolve(parsed.structured_output);
+            return;
+          }
+
+          // result alanında JSON string olabilir
+          if (parsed.result && typeof parsed.result === "string" && parsed.result.length > 2) {
+            try { resolve(JSON.parse(parsed.result)); return; } catch {}
+          }
+
+          // error_max_turns veya boş result durumunda - result'tan text çıkar
+          if (parsed.subtype === "error_max_turns" || !parsed.structured_output) {
+            // Claude tool kullanıp bitirmeden durmuş, sonucu elle çıkarmayı dene
+            reject(new Error(`Claude tamamlayamadı (${parsed.subtype || "unknown"}). max-turns artırılabilir.`));
+            return;
+          }
+
+          // Mesaj dizisi formatı
+          if (Array.isArray(parsed)) {
+            const last = parsed[parsed.length - 1];
+            const text = typeof last.content === "string"
+              ? last.content
+              : last.content?.map((c: any) => c.text || "").join("") || "";
+            resolve(JSON.parse(text));
+            return;
+          }
+
+          // Direkt obje
+          if (parsed.steps || parsed.selector) {
+            resolve(parsed);
+            return;
+          }
+
+          resolve(parsed);
+        } catch (parseErr: any) {
+          // Regex fallback
+          const match = output.match(/\{[\s\S]*\}/);
+          if (match) {
+            try { resolve(JSON.parse(match[0])); return; } catch {}
+          }
+          reject(new Error("Claude'dan geçerli JSON alınamadı"));
+        }
+        return;
+      }
+
+      if (code !== 0 && !output) {
+        reject(new Error(`Claude hata (code ${code}): ${stderr}`));
+        return;
+      }
+
+      resolve(output);
+    });
+
+    proc.on("error", (err) => {
+      rmSync(tmpDir, { recursive: true, force: true });
+      reject(err);
+    });
+
+    setTimeout(() => {
+      proc.kill();
+      reject(new Error("Claude timeout (180s)"));
+    }, 180000);
+  });
+}
+
+// ── Map CRUD ─────────────────────────────────────────────────
+
+export function loadMap(platform: string, action = "post"): SelectorMap | null {
+  const mapPath = join(PATHS.maps, `${platform}_${action}.json`);
+  if (!existsSync(mapPath)) return null;
+  return JSON.parse(readFileSync(mapPath, "utf-8"));
+}
+
+export function saveMap(map: SelectorMap): void {
+  const action = map.action || "post";
+  const mapPath = join(PATHS.maps, `${map.platform}_${action}.json`);
+  writeFileSync(mapPath, JSON.stringify(map, null, 2));
+}
+
+export function listMaps(platform?: string): SelectorMap[] {
+  const { readdirSync } = require("node:fs");
+  const maps: SelectorMap[] = [];
+  try {
+    for (const file of readdirSync(PATHS.maps)) {
+      if (!file.endsWith(".json")) continue;
+      if (platform && !file.startsWith(platform + "_")) continue;
+      const map = JSON.parse(readFileSync(join(PATHS.maps, file), "utf-8"));
+      maps.push(map);
+    }
+  } catch {}
+  return maps;
+}
+
+// ── Map Oluştur ──────────────────────────────────────────────
+
+export async function generateMap(
+  platform: string,
+  screenshotPath: string,
+  domSnapshot: string,
+  taskDescription = "yeni bir metin postu at",
+  actionName = "post"
+): Promise<SelectorMap> {
+  const prompt = `Sen bir browser otomasyon uzmanısın. ${platform} platformunda şu görevi yerine getirmek için adımları belirle:
+
+GÖREV: "${taskDescription}"
+
+DOM:
+${domSnapshot.substring(0, 50000)}
+
+Kurallar:
+- data-testid, aria-label, role, id tercih et
+- Her adım için 2+ fallback selector
+- Parametreler için placeholder kullan: {{CONTENT}} = metin, {{USERNAME}} = kullanıcı adı, {{URL}} = link, vs.
+- Hangi parametreleri kullandığını "parameters" alanında listele
+- action: "${actionName}"
+- platform: "${platform}", version: 1, lastUpdated: "${new Date().toISOString()}"
+- Gerekiyorsa "goto" action'ı ile belirli bir URL'e git (url alanını kullan)`;
+
+  console.log(`[claude] "${taskDescription}" analiz ediliyor...\n`);
+
+  let map: SelectorMap;
+  try {
+    map = await claude({
+      prompt,
+      jsonSchema: SELECTOR_MAP_SCHEMA,
+      imagePath: screenshotPath,
+      stream: true,
+      effort: "low",
+    });
+  } catch (err: any) {
+    console.error(`\n[claude] Hata: ${err.message}`);
+    throw err;
+  }
+
+  if (!map || !map.steps) {
+    throw new Error("Claude geçerli bir map döndürmedi");
+  }
+
+  map.platform = platform;
+  map.action = actionName;
+  map.description = taskDescription;
+  map.lastUpdated = new Date().toISOString();
+  saveMap(map);
+  return map;
+}
+
+// ── Self-Heal: Kaldığın yerden devam et ──────────────────────
+
+const REMAINING_STEPS_SCHEMA = JSON.stringify({
+  type: "object",
+  properties: {
+    analysis: { type: "string" },
+    remainingSteps: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          action: { type: "string", enum: ["click", "type", "wait", "keypress", "goto"] },
+          description: { type: "string" },
+          selector: { type: "string" },
+          value: { type: "string" },
+          key: { type: "string" },
+          url: { type: "string" },
+          waitMs: { type: "number" },
+          fallbackSelectors: { type: "array", items: { type: "string" } },
+        },
+        required: ["action", "description"],
+      },
+    },
+  },
+  required: ["analysis", "remainingSteps"],
+});
+
+/**
+ * Bir adım başarısız olduğunda AI ekranı görür,
+ * durumu analiz eder ve kalan adımları yeniden planlar.
+ * Sadece selector düzeltmez - tamamen yeni akış çizebilir.
+ */
+export async function healAndContinue(
+  platform: string,
+  failedStepIndex: number,
+  originalSteps: SelectorStep[],
+  screenshotPath: string,
+  domSnapshot: string,
+  errorMessage: string,
+  postContent: string,
+  effort = "low"
+): Promise<SelectorStep[]> {
+  const completedSteps = originalSteps.slice(0, failedStepIndex);
+  const failedStep = originalSteps[failedStepIndex];
+  const remainingOriginal = originalSteps.slice(failedStepIndex);
+
+  const prompt = `Bir browser otomasyon script'i çalışırken hata oluştu. Ekranın screenshot'ını ve DOM'unu görüyorsun.
+
+Platform: ${platform}
+Amaç: "${postContent}" metnini post olarak paylaşmak
+
+Tamamlanan adımlar:
+${completedSteps.map((s, i) => `  ${i + 1}. [${s.action}] ${s.description} ✓`).join("\n")}
+
+Başarısız olan adım (#${failedStepIndex + 1}):
+  [${failedStep.action}] ${failedStep.description}
+  Selector: ${failedStep.selector}
+  Hata: ${errorMessage}
+
+Kalan orijinal adımlar:
+${remainingOriginal.map((s, i) => `  ${failedStepIndex + i + 1}. [${s.action}] ${s.description} → ${s.selector}`).join("\n")}
+
+Güncel DOM:
+${domSnapshot.substring(0, 50000)}
+
+GÖREV: Ekranın mevcut durumunu analiz et. Amaca ulaşmak için kalan adımları yeniden planla.
+- Belki selector değişmiş → yeni selector bul
+- Belki ekstra bir adım gerekiyor (popup kapatma, scroll, vb.)
+- Belki farklı bir yol izlenmeli
+- {{CONTENT}} = post metni placeholder'ı
+- data-testid, aria-label, role tercih et, her adıma 2+ fallback selector ver`;
+
+  console.log(`\n[heal] AI ekranı analiz ediyor (effort: ${effort})...\n`);
+
+  const result = await claude({
+    prompt,
+    jsonSchema: REMAINING_STEPS_SCHEMA,
+    imagePath: screenshotPath,
+    stream: true,
+    effort,
+  });
+
+  console.log(`\n[heal] Analiz: ${result.analysis}`);
+  console.log(`[heal] ${result.remainingSteps.length} yeni adım planlandı`);
+
+  // Map'i güncelle: tamamlanan adımlar + yeni kalan adımlar
+  const currentMap = loadMap(platform);
+  if (currentMap) {
+    currentMap.steps = [...completedSteps, ...result.remainingSteps];
+    currentMap.version++;
+    currentMap.lastUpdated = new Date().toISOString();
+    saveMap(currentMap);
+  }
+
+  return result.remainingSteps;
+}

package/ai/planner.ts

@@ -0,0 +1,180 @@
+import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { PATHS } from "../core/config.js";
+import type { SelectorMap } from "../core/types.js";
+import { getPlatformKnowledge } from "./knowledge.js";
+export { addLearnedKnowledge } from "./knowledge.js";
+
+// claude fonksiyonunu mapper'dan import etmek yerine aynı şekilde çağıracağız
+// (mapper'daki claude private, export etmemiz lazım)
+// Bunun yerine planner kendi claude wrapper'ını kullanacak
+import { spawn } from "node:child_process";
+import { writeFileSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+
+// ── Claude wrapper (planner için) ────────────────────────────
+
+function claudeJSON(prompt: string, schema: string): Promise<any> {
+  const tmpDir = mkdtempSync(join(tmpdir(), "planner-"));
+  const promptFile = join(tmpDir, "prompt.txt");
+  writeFileSync(promptFile, prompt);
+
+  const cmd = `cat '${promptFile}' | claude -p --model opus --effort low --max-turns 3 --tools "" --output-format json --json-schema '${schema}'`;
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn("bash", ["-c", cmd], { stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+
+    proc.stdout.on("data", (chunk: Buffer) => {
+      const text = chunk.toString();
+      stdout += text;
+      process.stdout.write(text);
+    });
+
+    proc.on("close", () => {
+      rmSync(tmpDir, { recursive: true, force: true });
+      process.stdout.write("\n");
+      try {
+        const parsed = JSON.parse(stdout.trim());
+        if (parsed.structured_output) { resolve(parsed.structured_output); return; }
+        if (parsed.result && parsed.result.length > 2) { try { resolve(JSON.parse(parsed.result)); return; } catch {} }
+        if (parsed.steps || parsed.plan) { resolve(parsed); return; }
+        resolve(parsed);
+      } catch {
+        const match = stdout.match(/\{[\s\S]*\}/);
+        if (match) { try { resolve(JSON.parse(match[0])); return; } catch {} }
+        reject(new Error("Planner JSON parse hatası"));
+      }
+    });
+
+    proc.on("error", (err) => { rmSync(tmpDir, { recursive: true, force: true }); reject(err); });
+    setTimeout(() => { proc.kill(); reject(new Error("Planner timeout")); }, 60000);
+  });
+}
+
+// ── Mevcut map'leri listele ──────────────────────────────────
+
+export function listAllMaps(platform?: string): SelectorMap[] {
+  const maps: SelectorMap[] = [];
+  try {
+    for (const file of readdirSync(PATHS.maps)) {
+      if (!file.endsWith(".json")) continue;
+      if (platform && !file.startsWith(platform + "_")) continue;
+      const map = JSON.parse(readFileSync(join(PATHS.maps, file), "utf-8"));
+      maps.push(map);
+    }
+  } catch {}
+  return maps;
+}
+
+// ── Plan tipi ────────────────────────────────────────────────
+
+export interface ExecutionPlan {
+  analysis: string;
+  steps: PlanStep[];
+}
+
+export interface PlanStep {
+  type: "use_map" | "learn_new";
+  mapAction?: string;        // mevcut map'in action adı (use_map için)
+  learnDescription?: string; // öğrenilecek görev açıklaması (learn_new için)
+  learnActionName?: string;  // oluşturulacak map adı
+  parameters: Record<string, string>;  // {{TWEET_URL}}: "...", {{USERNAME}}: "..."
+  repeat?: number;           // kaç kez tekrarla (beğeni gibi loop işlemler)
+  description: string;       // adımın insan-okunur açıklaması
+}
+
+const PLAN_SCHEMA = JSON.stringify({
+  type: "object",
+  properties: {
+    analysis: { type: "string" },
+    steps: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          type: { type: "string", enum: ["use_map", "learn_new"] },
+          mapAction: { type: "string" },
+          learnDescription: { type: "string" },
+          learnActionName: { type: "string" },
+          parameters: { type: "object" },
+          repeat: { type: "number" },
+          description: { type: "string" },
+        },
+        required: ["type", "description", "parameters"],
+      },
+    },
+  },
+  required: ["analysis", "steps"],
+});
+
+// ── Ana planlama fonksiyonu ──────────────────────────────────
+
+export async function createPlan(
+  platform: string,
+  naturalLanguageCommand: string
+): Promise<ExecutionPlan> {
+  const maps = listAllMaps(platform);
+
+  const mapsDescription = maps.length
+    ? maps.map((m) => {
+        const params = m.parameters?.join(", ") || "yok";
+        return `- "${m.action}" → ${m.description || m.action} [parametreler: ${params}] (${m.steps.length} adım)`;
+      }).join("\n")
+    : "Henüz öğrenilmiş aksiyon yok.";
+
+  // Platform hakkında bilgi (kullanıcı tarafından yazılmış + AI öğrenmeleri)
+  const knowledge = getPlatformKnowledge(platform);
+
+  const prompt = `Sen bir sosyal medya otomasyon planlayıcısısın.
+
+Platform: ${platform}
+Platform bilgisi:
+${knowledge.substring(0, 5000)}
+
+Kullanıcı komutu: "${naturalLanguageCommand}"
+
+Mevcut öğrenilmiş aksiyonlar (map'ler):
+${mapsDescription}
+
+GÖREV: Bu komutu yerine getirmek için bir çalıştırma planı oluştur.
+
+Kurallar:
+- Mevcut map varsa "use_map" kullan, mapAction'a action adını yaz
+- Mevcut map yoksa "learn_new" kullan, AI otomatik öğrenecek
+- Parametreleri doldur ({{TWEET_URL}}, {{USERNAME}}, {{CONTENT}} vb.)
+- Belirli kişi/URL verilmemişse platformun keşif/öneri sayfalarını kullan (ör: LinkedIn'de ağım sayfası)
+- Tekrar eden işlemler için "repeat" kullan
+- Adımları doğru sırada planla
+- Kısa ve net analiz yaz`;
+
+  console.log(`[planner] "${naturalLanguageCommand}" planlanıyor...\n`);
+
+  let plan: ExecutionPlan;
+  try {
+    plan = await claudeJSON(prompt, PLAN_SCHEMA);
+  } catch (err: any) {
+    console.error(`\n[planner] Hata: ${err.message}`);
+    throw err;
+  }
+
+  if (!plan || !plan.steps) {
+    throw new Error("Planner geçerli bir plan oluşturamadı");
+  }
+
+  console.log(`\n[planner] Analiz: ${plan.analysis}`);
+  console.log(`[planner] ${plan.steps.length} adımlı plan oluşturuldu:\n`);
+
+  for (const [i, step] of plan.steps.entries()) {
+    const icon = step.type === "use_map" ? "▶" : "📚";
+    const repeat = step.repeat && step.repeat > 1 ? ` (x${step.repeat})` : "";
+    console.log(`  ${i + 1}. ${icon} ${step.description}${repeat}`);
+    if (step.type === "use_map") {
+      console.log(`     map: ${step.mapAction} | params: ${JSON.stringify(step.parameters)}`);
+    } else {
+      console.log(`     öğrenilecek: "${step.learnDescription}" → ${step.learnActionName}`);
+    }
+  }
+
+  return plan;
+}