@askexenow/exe-os 0.9.263 → 0.9.265

package/dist/skill-refinement-BSX6Q6IN.js

@@ -0,0 +1,157 @@
+import {
+  getClient
+} from "./chunk-QQZMP6QL.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-ACBEUQR2.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-VXIMSRTO.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lib/skill-refinement.ts
+import crypto from "crypto";
+async function incrementSkillUsage(behaviors) {
+  const skills = behaviors.filter((b) => b.domain === "skill");
+  if (skills.length === 0) return;
+  try {
+    const client = getClient();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const skill of skills) {
+      await client.execute({
+        sql: `UPDATE behaviors SET use_count = use_count + 1, last_used_at = ?, updated_at = ? WHERE id = ?`,
+        args: [now, now, skill.id]
+      });
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[skill-refinement] Failed to increment usage: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+async function incrementSkillSuccess(assignedTo, projectName) {
+  try {
+    const client = getClient();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const cutoff = new Date(Date.now() - 24 * 60 * 60 * 1e3).toISOString();
+    const rows = await client.execute({
+      sql: `SELECT id FROM behaviors
+            WHERE agent_id = ? AND domain = 'skill' AND active = 1
+            AND use_count > 0 AND last_used_at > ?
+            ${projectName ? "AND (project_name = ? OR project_name IS NULL)" : ""}`,
+      args: projectName ? [assignedTo, cutoff, projectName] : [assignedTo, cutoff]
+    });
+    for (const row of rows.rows) {
+      const id = String(row.id);
+      await client.execute({
+        sql: `UPDATE behaviors SET success_count = success_count + 1, updated_at = ? WHERE id = ?`,
+        args: [now, id]
+      });
+    }
+    if (rows.rows.length > 0) {
+      process.stderr.write(
+        `[skill-refinement] Incremented success_count for ${rows.rows.length} skill(s) (agent: ${assignedTo})
+`
+      );
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[skill-refinement] Failed to increment success: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+var MIN_USES_FOR_REVIEW = 3;
+var LOW_SUCCESS_RATE = 0.8;
+var HIGH_SUCCESS_RATE = 0.9;
+var MIN_USES_FOR_PROMOTION = 10;
+async function runSkillRefinement() {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const result = {
+    reviewed: 0,
+    flaggedLowSuccess: 0,
+    boostedConfidence: 0,
+    promotedToIdentity: 0
+  };
+  const rows = await client.execute({
+    sql: `SELECT id, agent_id, content, use_count, success_count, last_refined_at, project_name
+          FROM behaviors
+          WHERE domain = 'skill' AND active = 1 AND use_count >= ?`,
+    args: [MIN_USES_FOR_REVIEW]
+  });
+  for (const rawRow of rows.rows) {
+    const row = rawRow;
+    result.reviewed++;
+    const successRate = row.use_count > 0 ? row.success_count / row.use_count : 0;
+    if (successRate < LOW_SUCCESS_RATE) {
+      result.flaggedLowSuccess++;
+      const { writeMemory } = await import("./lib/store.js");
+      await writeMemory({
+        id: crypto.randomUUID(),
+        agent_id: row.agent_id,
+        agent_role: "",
+        session_id: "",
+        timestamp: now,
+        tool_name: "skill-refinement",
+        project_name: row.project_name ?? "",
+        has_error: false,
+        raw_text: `SKILL REVIEW NEEDED: "${row.content.slice(0, 100)}..." has ${Math.round(successRate * 100)}% success rate (${row.success_count}/${row.use_count} uses). Consider revising or deactivating.`,
+        vector: null,
+        memory_type: "observation"
+      });
+      await client.execute({
+        sql: `UPDATE behaviors SET last_refined_at = ?, updated_at = ? WHERE id = ?`,
+        args: [now, now, row.id]
+      });
+    } else if (row.use_count >= MIN_USES_FOR_PROMOTION && successRate > HIGH_SUCCESS_RATE) {
+      result.promotedToIdentity++;
+      try {
+        const { getIdentity, updateIdentity } = await import("./lib/identity.js");
+        const identity = await getIdentity(row.agent_id);
+        if (identity) {
+          const promotionBlock = `
+
+## Promoted Skill (auto-promoted ${now.split("T")[0]})
+${row.content}`;
+          await updateIdentity(row.agent_id, identity + promotionBlock, "skill-refinement");
+        }
+        await client.execute({
+          sql: `UPDATE behaviors SET active = 0, last_refined_at = ?, updated_at = ? WHERE id = ?`,
+          args: [now, now, row.id]
+        });
+        const { writeMemory: writePromoMemory } = await import("./lib/store.js");
+        await writePromoMemory({
+          id: crypto.randomUUID(),
+          agent_id: row.agent_id,
+          agent_role: "",
+          session_id: "",
+          timestamp: now,
+          tool_name: "skill-refinement",
+          project_name: row.project_name ?? "",
+          has_error: false,
+          raw_text: `SKILL PROMOTED TO IDENTITY: "${row.content.slice(0, 100)}..." \u2014 ${row.success_count}/${row.use_count} uses (${Math.round(successRate * 100)}% success). Deactivated as behavior, appended to identity.`,
+          vector: null,
+          memory_type: "decision"
+        });
+      } catch (err) {
+        process.stderr.write(
+          `[skill-refinement] Failed to promote skill ${row.id}: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    } else if (successRate > HIGH_SUCCESS_RATE) {
+      result.boostedConfidence++;
+      await client.execute({
+        sql: `UPDATE behaviors SET priority = 'p0', last_refined_at = ?, updated_at = ? WHERE id = ? AND priority != 'p0'`,
+        args: [now, now, row.id]
+      });
+    }
+  }
+  return result;
+}
+export {
+  incrementSkillSuccess,
+  incrementSkillUsage,
+  runSkillRefinement
+};

package/dist/{support-outbox-SZVLHHZG.js → support-outbox-SO73Q5H2.js}

@@ -5,16 +5,19 @@ import {
 import "./chunk-MLKGABMK.js";
 
 // src/lib/support-outbox.ts
-import { readdirSync, readFileSync, writeFileSync, existsSync } from "fs";
+import { mkdirSync, readdirSync, readFileSync, writeFileSync, existsSync } from "fs";
 import path from "path";
 import os from "os";
 var EXE_DIR = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path.join(os.homedir(), ".exe-os");
 var BUG_DIR = path.join(EXE_DIR, "bug-reports");
 var FEATURE_DIR = path.join(EXE_DIR, "feature-requests");
+var STATUS_UPDATE_DIR = path.join(EXE_DIR, "support-status-updates");
 var SKIPPED_MARKER = "upstream_skipped: ttl_expired";
 var TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 var BUG_ENDPOINT = "https://api.askexe.com/v1/support/bug-reports";
 var FEATURE_ENDPOINT = "https://api.askexe.com/v1/support/feature-requests";
+var CUSTOMER_STATUS_BASE_ENDPOINT = "https://api.askexe.com/v1/support";
+var ADMIN_STATUS_BASE_ENDPOINT = "https://api.askexe.com/admin/support";
 var DEFAULT_MAX_PER_FLUSH = 3;
 var consecutiveFailures = 0;
 var lastFailureTime = 0;
@@ -47,6 +50,35 @@ function loadSupportAdminToken() {
   const support = config?.support;
   return process.env.ASKEXE_SUPPORT_ADMIN_TOKEN || process.env.EXE_SUPPORT_ADMIN_TOKEN || support?.adminToken || support?.admin_token;
 }
+function normalizeBaseEndpoint(value, fallback) {
+  let raw = value || fallback;
+  try {
+    const parsed = new URL(raw);
+    if (parsed.hostname === "askexe.com" || parsed.hostname === "cloud.askexe.com") {
+      parsed.hostname = "api.askexe.com";
+      raw = parsed.toString();
+    }
+  } catch {
+  }
+  return raw.replace(/\/+$/, "").replace(/\/(bug-reports|feature-requests)\/?$/, "");
+}
+function buildStatusUpdateEndpoint(endpointPath, adminToken) {
+  const config = loadConfigFile();
+  const support = config?.support;
+  const routerUrl = process.env.API_ROUTER_URL?.replace(/\/+$/, "");
+  if (adminToken) {
+    const adminBase = normalizeBaseEndpoint(
+      process.env.ASKEXE_SUPPORT_ADMIN_ENDPOINT || support?.adminEndpoint || support?.admin_endpoint || ADMIN_STATUS_BASE_ENDPOINT,
+      ADMIN_STATUS_BASE_ENDPOINT
+    );
+    return `${adminBase}/${endpointPath.replace(/^\/+/, "")}`;
+  }
+  const customerBase = normalizeBaseEndpoint(
+    support?.bugReportEndpoint || process.env.EXE_BUG_REPORT_ENDPOINT || (routerUrl ? `${routerUrl}/v1/support` : CUSTOMER_STATUS_BASE_ENDPOINT),
+    CUSTOMER_STATUS_BASE_ENDPOINT
+  );
+  return `${customerBase}/${endpointPath.replace(/^\/+/, "")}`;
+}
 function readTrimmed(filePath) {
   try {
     const value = readFileSync(filePath, "utf-8").trim();
@@ -55,6 +87,56 @@ function readTrimmed(filePath) {
     return void 0;
   }
 }
+function statusUpdateFileName(kind, id) {
+  const safeId = id.replace(/[^a-z0-9-]/gi, "").slice(0, 64) || "unknown";
+  return `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${kind}-${safeId}.json`;
+}
+function findExistingUnsentStatusUpdate(kind, id) {
+  if (!existsSync(STATUS_UPDATE_DIR)) return void 0;
+  try {
+    for (const file of readdirSync(STATUS_UPDATE_DIR).filter((f) => f.endsWith(".json"))) {
+      const filePath = path.join(STATUS_UPDATE_DIR, file);
+      const record = JSON.parse(readFileSync(filePath, "utf-8"));
+      if (record.kind === kind && record.id === id && !record.sent_at) return filePath;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function queueSupportStatusUpdateSync(input) {
+  const id = input.id.trim();
+  if (!id) return void 0;
+  try {
+    mkdirSync(STATUS_UPDATE_DIR, { recursive: true });
+    const existingPath = findExistingUnsentStatusUpdate(input.kind, id);
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    const filePath = existingPath ?? path.join(STATUS_UPDATE_DIR, statusUpdateFileName(input.kind, id));
+    let attempts = 0;
+    if (existingPath) {
+      try {
+        const existing = JSON.parse(readFileSync(existingPath, "utf-8"));
+        attempts = existing.attempts ?? 0;
+      } catch {
+        attempts = 0;
+      }
+    }
+    const record = {
+      id,
+      kind: input.kind,
+      endpointPath: input.endpointPath,
+      method: input.method ?? "PATCH",
+      payload: input.payload,
+      created_at: existingPath ? JSON.parse(readFileSync(existingPath, "utf-8")).created_at : createdAt,
+      attempts,
+      last_error: input.lastError
+    };
+    writeFileSync(filePath, JSON.stringify(record, null, 2), "utf-8");
+    return filePath;
+  } catch {
+    return void 0;
+  }
+}
 function extractField(content, field) {
   const match = content.match(new RegExp(`^${field}:\\s*(.+)$`, "m"));
   return match?.[1]?.trim();
@@ -240,26 +322,115 @@ ${SKIPPED_MARKER}
   }
   return { sent, errors, skipped };
 }
+async function sendStatusUpdateRecord(record, filePath, licenseKey, licenseToken, adminToken) {
+  const endpoint = buildStatusUpdateEndpoint(record.endpointPath, adminToken);
+  const resp = await fetch(endpoint, {
+    method: record.method ?? "PATCH",
+    headers: {
+      "content-type": "application/json",
+      ...adminToken ? { authorization: `Bearer ${adminToken}` } : {},
+      ...!adminToken && licenseKey ? { "x-exe-license-key": licenseKey } : {},
+      ...!adminToken && licenseToken ? { "x-exe-license-token": licenseToken } : {}
+    },
+    body: JSON.stringify(record.payload),
+    signal: AbortSignal.timeout(5e3)
+  });
+  if (resp.ok) {
+    writeFileSync(filePath, JSON.stringify({ ...record, sent_at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), "utf-8");
+    onNetworkSuccess();
+    return true;
+  }
+  writeFileSync(filePath, JSON.stringify({
+    ...record,
+    attempts: (record.attempts ?? 0) + 1,
+    last_error: `HTTP ${resp.status}`,
+    last_attempt_at: (/* @__PURE__ */ new Date()).toISOString()
+  }, null, 2), "utf-8");
+  onNetworkFailure();
+  return false;
+}
+async function flushStatusUpdates(licenseKey, licenseToken, adminToken, maxPerFlush) {
+  let sent = 0;
+  let errors = 0;
+  let skipped = 0;
+  if (!existsSync(STATUS_UPDATE_DIR)) return { sent, errors, skipped };
+  let files;
+  try {
+    files = readdirSync(STATUS_UPDATE_DIR).filter((f) => f.endsWith(".json")).sort();
+  } catch {
+    return { sent, errors, skipped };
+  }
+  for (const file of files) {
+    if (sent >= maxPerFlush) break;
+    if (shouldBackoff()) break;
+    const filePath = path.join(STATUS_UPDATE_DIR, file);
+    let record;
+    try {
+      record = JSON.parse(readFileSync(filePath, "utf-8"));
+    } catch {
+      skipped++;
+      continue;
+    }
+    if (record.sent_at) {
+      skipped++;
+      continue;
+    }
+    try {
+      if (Date.now() - new Date(record.created_at).getTime() > TTL_MS) {
+        writeFileSync(filePath, JSON.stringify({
+          ...record,
+          skipped_at: (/* @__PURE__ */ new Date()).toISOString(),
+          last_error: "ttl_expired"
+        }, null, 2), "utf-8");
+        skipped++;
+        continue;
+      }
+    } catch {
+    }
+    try {
+      const ok = await sendStatusUpdateRecord(record, filePath, licenseKey, licenseToken, adminToken);
+      if (ok) sent++;
+      else errors++;
+    } catch (err) {
+      try {
+        writeFileSync(filePath, JSON.stringify({
+          ...record,
+          attempts: (record.attempts ?? 0) + 1,
+          last_error: err instanceof Error ? err.message : String(err),
+          last_attempt_at: (/* @__PURE__ */ new Date()).toISOString()
+        }, null, 2), "utf-8");
+      } catch {
+      }
+      onNetworkFailure();
+      errors++;
+      break;
+    }
+  }
+  return { sent, errors, skipped };
+}
 async function flushSupportOutbox(opts) {
   const maxPerFlush = opts?.maxPerFlush ?? DEFAULT_MAX_PER_FLUSH;
   const licenseKey = loadLicenseKey();
   const licenseToken = loadLicenseToken();
   const adminToken = loadSupportAdminToken();
-  const [bugs, features] = await Promise.all([
+  const [bugs, features, statusUpdates] = await Promise.all([
     flushDir(BUG_DIR, BUG_ENDPOINT, "bug", licenseKey, licenseToken, adminToken, maxPerFlush),
-    flushDir(FEATURE_DIR, FEATURE_ENDPOINT, "feature", licenseKey, licenseToken, adminToken, maxPerFlush)
+    flushDir(FEATURE_DIR, FEATURE_ENDPOINT, "feature", licenseKey, licenseToken, adminToken, maxPerFlush),
+    flushStatusUpdates(licenseKey, licenseToken, adminToken, maxPerFlush)
   ]);
   return {
     bugsSent: bugs.sent,
     featuresSent: features.sent,
-    errors: bugs.errors + features.errors,
-    skipped: bugs.skipped + features.skipped
+    statusUpdatesSent: statusUpdates.sent,
+    errors: bugs.errors + features.errors + statusUpdates.errors,
+    skipped: bugs.skipped + features.skipped + statusUpdates.skipped
   };
 }
 async function getOutboxStatus() {
   return {
     bugReports: scanDir(BUG_DIR),
-    featureRequests: scanDir(FEATURE_DIR)
+    featureRequests: scanDir(FEATURE_DIR),
+    statusUpdates: scanStatusDir(STATUS_UPDATE_DIR)
   };
 }
 function scanDir(dir) {
@@ -288,8 +459,32 @@ function scanDir(dir) {
   }
   return { total: files.length, unsent, oldest };
 }
+function scanStatusDir(dir) {
+  if (!existsSync(dir)) return { total: 0, unsent: 0 };
+  let files;
+  try {
+    files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+  } catch {
+    return { total: 0, unsent: 0 };
+  }
+  let unsent = 0;
+  let oldest;
+  for (const file of files) {
+    try {
+      const record = JSON.parse(readFileSync(path.join(dir, file), "utf-8"));
+      if (!record.sent_at) {
+        unsent++;
+        if (record.created_at && (!oldest || record.created_at < oldest)) oldest = record.created_at;
+      }
+    } catch {
+      unsent++;
+    }
+  }
+  return { total: files.length, unsent, oldest };
+}
 export {
   flushSupportOutbox as flushBugReportOutbox,
   flushSupportOutbox,
-  getOutboxStatus
+  getOutboxStatus,
+  queueSupportStatusUpdateSync
 };