@redscope-ai/redscope 1.0.0

package/dist/chunk-tb8sykbr.js

@@ -0,0 +1,426 @@
+// @bun
+import {
+  init_skillLearning
+} from "./chunk-r9b5xrh0.js";
+import {
+  promoteGapToDraft,
+  readSkillGaps
+} from "./chunk-19f3zb1m.js";
+import {
+  exportInstincts,
+  findPromotionCandidates,
+  generateSkillCandidates,
+  loadInstincts,
+  prunePendingInstincts,
+  saveInstinct,
+  upsertInstinct
+} from "./chunk-tb636bcf.js";
+import {
+  applySkillLifecycleDecision,
+  compareExistingSkills,
+  decideSkillLifecycle
+} from "./chunk-b0tjx3k1.js";
+import {
+  listKnownProjects,
+  resolveProjectContext
+} from "./chunk-fqcfzg3j.js";
+import {
+  analyzeObservations
+} from "./chunk-cnge6wpj.js";
+import"./chunk-w9ddp3yf.js";
+import"./chunk-fjn632v7.js";
+import {
+  ingestTranscript,
+  readObservations
+} from "./chunk-v3ey5j7f.js";
+import"./chunk-gmdy2w3z.js";
+import"./chunk-q0e485mg.js";
+import"./chunk-2kcgxnvp.js";
+import"./chunk-14p6wvsq.js";
+import"./chunk-6s0q1s5r.js";
+import"./chunk-3w9sye8h.js";
+import"./chunk-nzxfj0gq.js";
+import"./chunk-vr0n9pv9.js";
+import"./chunk-9a9g5hbj.js";
+import"./chunk-ptxteaeh.js";
+import"./chunk-w4p5t920.js";
+import"./chunk-rgyzsbs3.js";
+import"./chunk-q3b4n194.js";
+import"./chunk-kywtr3jg.js";
+import"./chunk-eewg66y1.js";
+import"./chunk-71sdcaq6.js";
+import"./chunk-9hn8e6h1.js";
+import"./chunk-7qey87th.js";
+import"./chunk-zw62m6n3.js";
+import"./chunk-1w20m7gw.js";
+import"./chunk-zzf074w3.js";
+import"./chunk-rpmntgyh.js";
+import"./chunk-24kv69g3.js";
+import"./chunk-hzxzvzw8.js";
+import"./chunk-30wnahyg.js";
+import"./chunk-ztmb7geg.js";
+import"./chunk-tbdkekz3.js";
+import"./chunk-65zbgg1n.js";
+import"./chunk-4spgkgr3.js";
+import"./chunk-60fkafk2.js";
+import"./chunk-50m3a23z.js";
+import"./chunk-6hygvrhn.js";
+import"./chunk-7tfdhkpy.js";
+import"./chunk-8gv2pjby.js";
+import"./chunk-g06pm4n9.js";
+import"./chunk-2p369q9z.js";
+import"./chunk-z0jgeax8.js";
+import"./chunk-w68wc625.js";
+import"./chunk-6hr7742d.js";
+import"./chunk-xyg1sk2w.js";
+import"./chunk-935nrvdb.js";
+import"./chunk-8zz4z1q3.js";
+import"./chunk-fncpkzs5.js";
+import"./chunk-hqxp6b72.js";
+import"./chunk-m2c3bjv1.js";
+import"./chunk-jhtccjc9.js";
+import"./chunk-7nvday0n.js";
+import"./chunk-vxbjzggp.js";
+import"./chunk-yc1stfve.js";
+import"./chunk-8yvsnrkr.js";
+import"./chunk-5mmhfbxb.js";
+import"./chunk-eemjb825.js";
+import"./chunk-ga1jkyqy.js";
+import"./chunk-y1q7rt9n.js";
+import"./chunk-8kct9arg.js";
+import"./chunk-k7hexw3v.js";
+import"./chunk-trqrj23e.js";
+import"./chunk-za3k6h2h.js";
+import"./chunk-8kf8h7xf.js";
+import"./chunk-bgan4cpf.js";
+import"./chunk-jmv7k0jn.js";
+import"./chunk-hjxqmtg5.js";
+import"./chunk-bzyzrq0k.js";
+import"./chunk-vwenx8ke.js";
+import"./chunk-q2h79ncs.js";
+import"./chunk-v4ypszbb.js";
+import"./chunk-qfsn720k.js";
+import"./chunk-7qx3xhv3.js";
+import"./chunk-j9475b46.js";
+import"./chunk-fdwabr8p.js";
+import"./chunk-e4dsy4g1.js";
+import"./chunk-326zehp8.js";
+import"./chunk-kc67kt75.js";
+import"./chunk-40t1d75v.js";
+import"./chunk-dbts5q5p.js";
+import"./chunk-e3abfxpy.js";
+import"./chunk-q44zc68f.js";
+import"./chunk-fejeqe61.js";
+import"./chunk-q1vrhh0q.js";
+import"./chunk-hn4w9pkj.js";
+import"./chunk-2g0ytd9d.js";
+import"./chunk-de0qnnf7.js";
+import"./chunk-j1mep9ck.js";
+import"./chunk-6x35ffpx.js";
+import"./chunk-1zbwhcbt.js";
+import"./chunk-92bjkrf2.js";
+import"./chunk-10k5jfc5.js";
+import"./chunk-n9g24mwe.js";
+import"./chunk-e3j7m7k2.js";
+import"./chunk-hzmzwte2.js";
+import"./chunk-pdvg91cg.js";
+import"./chunk-c696122m.js";
+import"./chunk-xbj5keyy.js";
+import"./chunk-c1yc761e.js";
+import"./chunk-c5g9shkw.js";
+import"./chunk-aeysytks.js";
+import {
+  getClaudeConfigHomeDir,
+  init_envUtils
+} from "./chunk-s3hafnk3.js";
+import"./chunk-kb3758f7.js";
+import"./chunk-9h9k5vz3.js";
+import"./chunk-xmpgmeb8.js";
+import"./chunk-2kz09j2s.js";
+import"./chunk-c0k7b0jw.js";
+import"./chunk-pecy49yr.js";
+import"./chunk-azbab59e.js";
+import"./chunk-3nk9q8dr.js";
+import {
+  __esm,
+  __require
+} from "./chunk-hhsxm2yr.js";
+
+// src/commands/skill-learning/skill-learning.ts
+import { join } from "path";
+function parseFlagString(parts, flag) {
+  const eqForm = parts.find((p) => p.startsWith(`${flag}=`));
+  if (eqForm)
+    return eqForm.slice(flag.length + 1) || undefined;
+  const idx = parts.indexOf(flag);
+  if (idx >= 0 && parts[idx + 1] && !parts[idx + 1].startsWith("--")) {
+    return parts[idx + 1];
+  }
+  return;
+}
+function parseFlagNumber(parts, flag, fallback) {
+  const raw = parseFlagString(parts, flag);
+  if (raw === undefined)
+    return fallback;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : fallback;
+}
+var call = async (args) => {
+  const parts = args.trim().split(/\s+/).filter(Boolean);
+  const sub = parts[0] ?? "status";
+  const project = resolveProjectContext(process.cwd());
+  const rootDir = process.env.CLAUDE_SKILL_LEARNING_HOME;
+  const options = { project, rootDir };
+  switch (sub) {
+    case "status": {
+      const [observations, instincts] = await Promise.all([
+        readObservations(options),
+        loadInstincts(options)
+      ]);
+      return {
+        type: "text",
+        value: [
+          `Skill Learning status for ${project.projectName} (${project.projectId})`,
+          `Observations: ${observations.length}`,
+          `Instincts: ${instincts.length}`
+        ].join(`
+`)
+      };
+    }
+    case "ingest": {
+      const transcript = parts[1];
+      if (!transcript) {
+        return {
+          type: "text",
+          value: "Usage: /skill-learning ingest <transcript.jsonl> [--min-session-length=<n>]"
+        };
+      }
+      const minSessionLength = parseFlagNumber(parts, "--min-session-length", 10);
+      const observations = await ingestTranscript(transcript, options);
+      if (observations.length < minSessionLength) {
+        return {
+          type: "text",
+          value: `Session too short for learning (${observations.length} < min=${minSessionLength}). Skipping instinct extraction.`
+        };
+      }
+      const instincts = analyzeObservations(observations);
+      const saved = [];
+      for (const instinct of instincts) {
+        saved.push(await upsertInstinct(instinct, options));
+      }
+      return {
+        type: "text",
+        value: `Ingested ${observations.length} observations and saved ${saved.length} instincts.`
+      };
+    }
+    case "evolve": {
+      const generate = parts.includes("--generate");
+      const instincts = await loadInstincts(options);
+      const drafts = generateSkillCandidates(instincts, { cwd: process.cwd() });
+      const written = [];
+      if (generate) {
+        for (const draft of drafts) {
+          const roots = [
+            join(process.cwd(), ".claude", "skills"),
+            join(getClaudeConfigHomeDir(), "skills")
+          ];
+          const existing = await compareExistingSkills(draft, roots);
+          const decision = decideSkillLifecycle(draft, existing);
+          const result = await applySkillLifecycleDecision(decision);
+          written.push(`${decision.type}: ${result.activePath ?? result.archivedPath ?? result.deletedPath ?? "no active write"}`);
+        }
+      }
+      return {
+        type: "text",
+        value: generate ? `Generated ${written.length} learned skill(s):
+${written.join(`
+`)}` : `Found ${drafts.length} skill candidate(s). Use --generate to write them.`
+      };
+    }
+    case "export": {
+      const output = parts[1] ?? "skill-learning-instincts.json";
+      const scope = parseFlagString(parts, "--scope");
+      const minConf = parseFlagNumber(parts, "--min-conf", undefined);
+      const domain = parseFlagString(parts, "--domain");
+      const filter = (instincts) => instincts.filter((i) => {
+        if (scope && i.scope !== scope)
+          return false;
+        if (minConf !== undefined && i.confidence < minConf)
+          return false;
+        if (domain && i.domain !== domain)
+          return false;
+        return true;
+      });
+      const all = await loadInstincts(options);
+      const filtered = filter(all);
+      if (filtered.length !== all.length) {
+        await exportInstincts(output, options);
+        const { writeFile } = await import("fs/promises");
+        await writeFile(output, `${JSON.stringify(filtered, null, 2)}
+`);
+      } else {
+        await exportInstincts(output, options);
+      }
+      const parts2 = [
+        `Exported ${filtered.length} instincts to ${output}`
+      ];
+      if (scope || minConf !== undefined || domain) {
+        const filters = [];
+        if (scope)
+          filters.push(`scope=${scope}`);
+        if (minConf !== undefined)
+          filters.push(`min-conf=${minConf}`);
+        if (domain)
+          filters.push(`domain=${domain}`);
+        parts2.push(`(filters: ${filters.join(", ")})`);
+      }
+      return { type: "text", value: parts2.join(" ") };
+    }
+    case "import": {
+      const input = parts[1];
+      if (!input) {
+        return {
+          type: "text",
+          value: "Usage: /skill-learning import <instincts.json> [--scope=<scope>] [--min-conf=<n>] [--domain=<d>] [--dry-run]"
+        };
+      }
+      const scope = parseFlagString(parts, "--scope");
+      const minConf = parseFlagNumber(parts, "--min-conf", undefined);
+      const domain = parseFlagString(parts, "--domain");
+      const dryRun = parts.includes("--dry-run");
+      const { readFile: readFileFs } = await import("fs/promises");
+      const parsed = JSON.parse(await readFileFs(input, "utf8"));
+      const filtered = parsed.filter((i) => {
+        if (scope && i.scope !== scope)
+          return false;
+        if (minConf !== undefined && i.confidence < minConf)
+          return false;
+        if (domain && i.domain !== domain)
+          return false;
+        return true;
+      });
+      if (dryRun) {
+        return {
+          type: "text",
+          value: `Dry run: would import ${filtered.length}/${parsed.length} instincts.`
+        };
+      }
+      for (const instinct of filtered) {
+        await upsertInstinct(instinct, options);
+      }
+      return {
+        type: "text",
+        value: `Imported ${filtered.length}/${parsed.length} instincts.`
+      };
+    }
+    case "prune": {
+      const maxAgeIndex = parts.indexOf("--max-age");
+      const maxAge = maxAgeIndex >= 0 && parts[maxAgeIndex + 1] ? Number(parts[maxAgeIndex + 1]) : 30;
+      const pruned = await prunePendingInstincts(maxAge, options);
+      return {
+        type: "text",
+        value: `Pruned ${pruned.length} pending instincts.`
+      };
+    }
+    case "promote": {
+      const target = parts[1];
+      if (!target) {
+        const gaps = await readSkillGaps(project, rootDir);
+        const instincts = await loadInstincts(options);
+        const candidates = findPromotionCandidates(instincts);
+        const lines = [
+          `Promotion candidates for ${project.projectName} (${project.projectId}):`,
+          `Pending gaps: ${gaps.filter((g) => g.status === "pending").length}`,
+          `Global-eligible instincts (>=2 projects, avg confidence >=0.8): ${candidates.length}`,
+          "",
+          "Usage:",
+          "  /skill-learning promote gap <gap-key>           # pending gap -> draft",
+          "  /skill-learning promote instinct <instinct-id>  # project instinct -> global"
+        ];
+        return { type: "text", value: lines.join(`
+`) };
+      }
+      if (target === "gap") {
+        const gapKey = parts[2];
+        if (!gapKey) {
+          return {
+            type: "text",
+            value: "Usage: /skill-learning promote gap <gap-key>"
+          };
+        }
+        const updated = await promoteGapToDraft(gapKey, project, rootDir);
+        if (!updated) {
+          return { type: "text", value: `No gap found for key "${gapKey}".` };
+        }
+        return {
+          type: "text",
+          value: `Promoted gap ${gapKey} to status=${updated.status} (draft=${updated.draft?.skillPath ?? "none"}).`
+        };
+      }
+      if (target === "instinct") {
+        const instinctId = parts[2];
+        if (!instinctId) {
+          return {
+            type: "text",
+            value: "Usage: /skill-learning promote instinct <instinct-id>"
+          };
+        }
+        const projectInstincts = await loadInstincts(options);
+        const match = projectInstincts.find((i) => i.id === instinctId);
+        if (!match) {
+          return {
+            type: "text",
+            value: `No project-scoped instinct found for id "${instinctId}".`
+          };
+        }
+        if (match.scope === "global") {
+          return {
+            type: "text",
+            value: `Instinct ${instinctId} is already global.`
+          };
+        }
+        const globalCopy = { ...match, scope: "global" };
+        await saveInstinct(globalCopy, { scope: "global", rootDir });
+        return {
+          type: "text",
+          value: `Promoted instinct ${instinctId} to global scope.`
+        };
+      }
+      return {
+        type: "text",
+        value: "Usage: /skill-learning promote [gap <gap-key>|instinct <instinct-id>]"
+      };
+    }
+    case "projects": {
+      const projects = listKnownProjects();
+      if (projects.length === 0) {
+        return { type: "text", value: "No known project scopes yet." };
+      }
+      const lines = ["Known project scopes:"];
+      for (const record of projects) {
+        const projectOptions = { project: record, rootDir };
+        const [instincts, observations] = await Promise.all([
+          loadInstincts(projectOptions),
+          readObservations(projectOptions)
+        ]);
+        lines.push(`- ${record.projectName} (${record.projectId}) \u2014 instincts: ${instincts.length}, observations: ${observations.length}, lastSeen: ${record.lastSeenAt}`);
+      }
+      return { type: "text", value: lines.join(`
+`) };
+    }
+    default:
+      return {
+        type: "text",
+        value: "Usage: /skill-learning [status|ingest|evolve|export|import|prune|promote|projects]"
+      };
+  }
+};
+var init_skill_learning = __esm(() => {
+  init_envUtils();
+  init_skillLearning();
+});
+init_skill_learning();
+
+export {
+  call
+};

package/dist/chunk-tbdkekz3.js

@@ -0,0 +1,125 @@
+// @bun
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-j1mep9ck.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  jsonStringify,
+  logForDebugging
+} from "./chunk-s3hafnk3.js";
+import {
+  __esm,
+  __export
+} from "./chunk-hhsxm2yr.js";
+
+// src/bridge/sessionIdCompat.ts
+var exports_sessionIdCompat = {};
+__export(exports_sessionIdCompat, {
+  toInfraSessionId: () => toInfraSessionId,
+  toCompatSessionId: () => toCompatSessionId,
+  setCseShimGate: () => setCseShimGate
+});
+function setCseShimGate(gate) {
+  _isCseShimEnabled = gate;
+}
+function toCompatSessionId(id) {
+  if (!id.startsWith("cse_"))
+    return id;
+  if (_isCseShimEnabled && !_isCseShimEnabled())
+    return id;
+  return "session_" + id.slice("cse_".length);
+}
+function toInfraSessionId(id) {
+  if (!id.startsWith("session_"))
+    return id;
+  return "cse_" + id.slice("session_".length);
+}
+var _isCseShimEnabled;
+var init_sessionIdCompat = () => {};
+
+// src/bridge/debugUtils.ts
+function redactSecrets(s) {
+  return s.replace(SECRET_PATTERN, (_match, field, value) => {
+    if (value.length < REDACT_MIN_LENGTH) {
+      return `"${field}":"[REDACTED]"`;
+    }
+    const redacted = `${value.slice(0, 8)}...${value.slice(-4)}`;
+    return `"${field}":"${redacted}"`;
+  });
+}
+function debugTruncate(s) {
+  const flat = s.replace(/\n/g, "\\n");
+  if (flat.length <= DEBUG_MSG_LIMIT) {
+    return flat;
+  }
+  return flat.slice(0, DEBUG_MSG_LIMIT) + `... (${flat.length} chars)`;
+}
+function debugBody(data) {
+  const raw = typeof data === "string" ? data : jsonStringify(data);
+  const s = redactSecrets(raw);
+  if (s.length <= DEBUG_MSG_LIMIT) {
+    return s;
+  }
+  return s.slice(0, DEBUG_MSG_LIMIT) + `... (${s.length} chars)`;
+}
+function describeAxiosError(err) {
+  const msg = errorMessage(err);
+  if (err && typeof err === "object" && "response" in err) {
+    const response = err.response;
+    if (response?.data && typeof response.data === "object") {
+      const data = response.data;
+      const detail = typeof data.message === "string" ? data.message : typeof data.error === "object" && data.error && ("message" in data.error) && typeof data.error.message === "string" ? data.error.message : undefined;
+      if (detail) {
+        return `${msg}: ${detail}`;
+      }
+    }
+  }
+  return msg;
+}
+function extractHttpStatus(err) {
+  if (err && typeof err === "object" && "response" in err && err.response && typeof err.response.status === "number") {
+    return err.response.status;
+  }
+  return;
+}
+function extractErrorDetail(data) {
+  if (!data || typeof data !== "object")
+    return;
+  if ("message" in data && typeof data.message === "string") {
+    return data.message;
+  }
+  if ("error" in data && data.error !== null && typeof data.error === "object" && "message" in data.error && typeof data.error.message === "string") {
+    return data.error.message;
+  }
+  return;
+}
+function logBridgeSkip(reason, debugMsg, v2) {
+  if (debugMsg) {
+    logForDebugging(debugMsg);
+  }
+  logEvent("tengu_bridge_repl_skipped", {
+    reason,
+    ...v2 !== undefined && { v2 }
+  });
+}
+var DEBUG_MSG_LIMIT = 2000, SECRET_FIELD_NAMES, SECRET_PATTERN, REDACT_MIN_LENGTH = 16;
+var init_debugUtils = __esm(() => {
+  init_analytics();
+  init_debug();
+  init_errors();
+  init_slowOperations();
+  SECRET_FIELD_NAMES = [
+    "session_ingress_token",
+    "environment_secret",
+    "access_token",
+    "secret",
+    "token"
+  ];
+  SECRET_PATTERN = new RegExp(`"(${SECRET_FIELD_NAMES.join("|")})"\\s*:\\s*"([^"]*)"`, "g");
+});
+
+export { setCseShimGate, toCompatSessionId, toInfraSessionId, exports_sessionIdCompat, init_sessionIdCompat, debugTruncate, debugBody, describeAxiosError, extractHttpStatus, extractErrorDetail, logBridgeSkip, init_debugUtils };