chainlesschain 0.37.10 → 0.37.12

package/src/lib/zkp-engine.js

@@ -0,0 +1,241 @@
+/**
+ * ZKP Engine — Zero-knowledge proof circuit compilation, proof generation,
+ * verification, and selective identity disclosure.
+ */
+
+import crypto from "crypto";
+
+/* ── In-memory stores ──────────────────────────────────────── */
+const _circuits = new Map();
+const _proofs = new Map();
+const _verificationKeys = new Map();
+
+const DEFAULT_SCHEME = "groth16";
+
+/* ── Schema ────────────────────────────────────────────────── */
+
+export function ensureZKPTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS zkp_circuits (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      definition TEXT,
+      compiled TEXT,
+      verification_key TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS zkp_proofs (
+      id TEXT PRIMARY KEY,
+      circuit_id TEXT NOT NULL,
+      proof TEXT,
+      public_inputs TEXT,
+      verified INTEGER DEFAULT 0,
+      scheme TEXT DEFAULT 'groth16',
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+}
+
+/* ── Circuit Compilation ───────────────────────────────────── */
+
+export function compileCircuit(db, name, definition) {
+  const id = crypto.randomUUID();
+  const now = new Date().toISOString();
+
+  // Parse definition to extract constraints and I/O
+  let parsed;
+  if (typeof definition === "string") {
+    try {
+      parsed = JSON.parse(definition);
+    } catch (_err) {
+      parsed = { constraints: [], inputs: [], outputs: [] };
+    }
+  } else {
+    parsed = definition || {};
+  }
+
+  const constraints = parsed.constraints || [];
+  const inputs = parsed.inputs || [];
+  const outputs = parsed.outputs || [];
+
+  // Generate verification key
+  const vkData = `${id}:${name}:${now}`;
+  const verificationKey = crypto
+    .createHash("sha256")
+    .update(vkData)
+    .digest("hex");
+
+  const compiled = {
+    bytecode: crypto.randomBytes(32).toString("hex"),
+    constraintCount: constraints.length || 1,
+    compiledAt: now,
+  };
+
+  const circuit = {
+    id,
+    name,
+    definition: parsed,
+    compiled,
+    constraints: constraints.length || 1,
+    inputs,
+    outputs,
+    verificationKey,
+    createdAt: now,
+  };
+
+  _circuits.set(id, circuit);
+  _verificationKeys.set(id, verificationKey);
+
+  db.prepare(
+    `INSERT INTO zkp_circuits (id, name, definition, compiled, verification_key, created_at)
+     VALUES (?, ?, ?, ?, ?, ?)`,
+  ).run(
+    id,
+    name,
+    JSON.stringify(parsed),
+    JSON.stringify(compiled),
+    verificationKey,
+    now,
+  );
+
+  return circuit;
+}
+
+/* ── Proof Generation ──────────────────────────────────────── */
+
+export function generateProof(db, circuitId, privateInputs, publicInputs) {
+  const circuit = _circuits.get(circuitId);
+  if (!circuit) throw new Error(`Circuit not found: ${circuitId}`);
+
+  const id = crypto.randomUUID();
+  const now = new Date().toISOString();
+
+  // Mock zk-SNARK proof with {a, b, c} components (Groth16 structure)
+  const proofData = {
+    a: crypto.randomBytes(32).toString("hex"),
+    b: crypto.randomBytes(64).toString("hex"),
+    c: crypto.randomBytes(32).toString("hex"),
+  };
+
+  const proof = {
+    id,
+    circuitId,
+    scheme: DEFAULT_SCHEME,
+    proof: proofData,
+    publicInputs: publicInputs || [],
+    verified: false,
+    createdAt: now,
+  };
+
+  _proofs.set(id, proof);
+
+  db.prepare(
+    `INSERT INTO zkp_proofs (id, circuit_id, proof, public_inputs, verified, scheme, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    id,
+    circuitId,
+    JSON.stringify(proofData),
+    JSON.stringify(publicInputs || []),
+    0,
+    DEFAULT_SCHEME,
+    now,
+  );
+
+  return proof;
+}
+
+/* ── Proof Verification ────────────────────────────────────── */
+
+export function verifyProof(db, proofId) {
+  const proof = _proofs.get(proofId);
+  if (!proof) throw new Error(`Proof not found: ${proofId}`);
+
+  const circuit = _circuits.get(proof.circuitId);
+  if (!circuit) throw new Error(`Circuit not found for proof: ${proofId}`);
+
+  // Mock verification — check proof structure is valid
+  const valid =
+    proof.proof &&
+    typeof proof.proof.a === "string" &&
+    typeof proof.proof.b === "string" &&
+    typeof proof.proof.c === "string" &&
+    _verificationKeys.has(proof.circuitId);
+
+  proof.verified = valid;
+
+  db.prepare(`UPDATE zkp_proofs SET verified = ? WHERE id = ?`).run(
+    valid ? 1 : 0,
+    proofId,
+  );
+
+  return { valid, proofId, circuitId: proof.circuitId, scheme: proof.scheme };
+}
+
+/* ── Identity Proof (Selective Disclosure) ─────────────────── */
+
+export function createIdentityProof(claims, disclosedFields) {
+  if (!claims || typeof claims !== "object") {
+    throw new Error("Claims must be an object");
+  }
+
+  const allFields = Object.keys(claims);
+  const disclosed = {};
+  const hiddenFields = [];
+
+  for (const field of allFields) {
+    if (disclosedFields && disclosedFields.includes(field)) {
+      disclosed[field] = claims[field];
+    } else {
+      hiddenFields.push(field);
+    }
+  }
+
+  const commitment = crypto
+    .createHash("sha256")
+    .update(JSON.stringify(claims))
+    .digest("hex");
+
+  return {
+    id: crypto.randomUUID(),
+    type: "selective-disclosure",
+    disclosed,
+    hiddenCount: hiddenFields.length,
+    commitment,
+  };
+}
+
+/* ── Stats ─────────────────────────────────────────────────── */
+
+export function getZKPStats() {
+  const proofList = [..._proofs.values()];
+  return {
+    circuits: _circuits.size,
+    proofs: proofList.length,
+    verifiedProofs: proofList.filter((p) => p.verified).length,
+  };
+}
+
+/* ── Listing ───────────────────────────────────────────────── */
+
+export function listCircuits(db) {
+  return [..._circuits.values()];
+}
+
+export function listProofs(db, options) {
+  let proofs = [..._proofs.values()];
+  if (options && options.circuitId) {
+    proofs = proofs.filter((p) => p.circuitId === options.circuitId);
+  }
+  return proofs;
+}
+
+/* ── Reset (for testing) ───────────────────────────────────── */
+
+export function _resetState() {
+  _circuits.clear();
+  _proofs.clear();
+  _verificationKeys.clear();
+}

package/src/repl/agent-repl.js

@@ -25,6 +25,7 @@ import { execSync } from "child_process";
 import { fileURLToPath } from "url";
 import { logger } from "../lib/logger.js";
 import { getPlanModeManager, PlanState } from "../lib/plan-mode.js";
+import { CLISkillLoader } from "../lib/skill-loader.js";
 
 /**
  * Tool definitions for function calling
@@ -189,77 +190,9 @@ const TOOLS = [
 ];
 
 /**
- * Find and load bundled skills (shared with skill command)
+ * Shared multi-layer skill loader
  */
-const __agentDirname = path.dirname(fileURLToPath(import.meta.url));
-
-function findSkillsDir() {
-  const candidates = [
-    path.resolve(
-      __agentDirname,
-      "../../../../../desktop-app-vue/src/main/ai-engine/cowork/skills/builtin",
-    ),
-    path.resolve(
-      process.cwd(),
-      "desktop-app-vue/src/main/ai-engine/cowork/skills/builtin",
-    ),
-  ];
-  for (const dir of candidates) {
-    if (fs.existsSync(dir)) return dir;
-  }
-  return null;
-}
-
-function loadSkillList(skillsDir) {
-  const skills = [];
-  try {
-    const dirs = fs.readdirSync(skillsDir, { withFileTypes: true });
-    for (const dir of dirs) {
-      if (!dir.isDirectory()) continue;
-      const skillMd = path.join(skillsDir, dir.name, "SKILL.md");
-      if (!fs.existsSync(skillMd)) continue;
-      try {
-        const content = fs.readFileSync(skillMd, "utf8");
-        const lines = content.split("\n");
-        if (lines[0].trim() !== "---") continue;
-        let endIndex = -1;
-        for (let i = 1; i < lines.length; i++) {
-          if (lines[i].trim() === "---") {
-            endIndex = i;
-            break;
-          }
-        }
-        if (endIndex === -1) continue;
-        const data = {};
-        for (const line of lines.slice(1, endIndex)) {
-          const ci = line.indexOf(":");
-          if (ci > 0) {
-            const key = line.slice(0, ci).trim();
-            const val = line
-              .slice(ci + 1)
-              .trim()
-              .replace(/^['"]|['"]$/g, "");
-            data[key] = val;
-          }
-        }
-        skills.push({
-          id: data.name || dir.name,
-          description: data.description || "",
-          category: data.category || "uncategorized",
-          dirName: dir.name,
-          hasHandler: fs.existsSync(
-            path.join(skillsDir, dir.name, "handler.js"),
-          ),
-        });
-      } catch {
-        // Skip malformed skill files
-      }
-    }
-  } catch {
-    // Skills dir unreadable
-  }
-  return skills;
-}
+const skillLoader = new CLISkillLoader();
 
 /**
  * Execute a tool call (with plan mode filtering)
@@ -394,50 +327,28 @@ async function executeTool(name, args) {
     }
 
     case "run_skill": {
-      const skillsDir = findSkillsDir();
-      if (!skillsDir) {
+      const allSkills = skillLoader.getResolvedSkills();
+      if (allSkills.length === 0) {
         return {
           error:
-            "Skills directory not found. Make sure you're in the ChainlessChain project root.",
+            "No skills found. Make sure you're in the ChainlessChain project root or have skills installed.",
         };
       }
-      const handlerPath = path.join(skillsDir, args.skill_name, "handler.js");
-      if (!fs.existsSync(handlerPath)) {
-        // Try fuzzy match
-        const skills = loadSkillList(skillsDir);
-        const match = skills.find(
-          (s) => s.id === args.skill_name || s.dirName === args.skill_name,
-        );
-        if (match && match.hasHandler) {
-          const matchedPath = path.join(skillsDir, match.dirName, "handler.js");
-          try {
-            const handler = (
-              await import(`file://${matchedPath.replace(/\\/g, "/")}`)
-            ).default;
-            const task = {
-              params: { input: args.input },
-              input: args.input,
-              action: args.input,
-            };
-            const context = {
-              projectRoot: process.cwd(),
-              workspacePath: process.cwd(),
-            };
-            const result = await handler.execute(task, context);
-            return result;
-          } catch (err) {
-            return { error: `Skill execution failed: ${err.message}` };
-          }
-        }
+      const match = allSkills.find(
+        (s) => s.id === args.skill_name || s.dirName === args.skill_name,
+      );
+      if (!match || !match.hasHandler) {
         return {
           error: `Skill "${args.skill_name}" not found or has no handler. Use list_skills to see available skills.`,
         };
       }
       try {
-        const handler = (
-          await import(`file://${handlerPath.replace(/\\/g, "/")}`)
-        ).default;
-        if (handler.init) await handler.init({});
+        const handlerPath = path.join(match.skillDir, "handler.js");
+        const imported = await import(
+          `file://${handlerPath.replace(/\\/g, "/")}`
+        );
+        const handler = imported.default || imported;
+        if (handler.init) await handler.init(match);
         const task = {
           params: { input: args.input },
           input: args.input,
@@ -447,7 +358,7 @@ async function executeTool(name, args) {
           projectRoot: process.cwd(),
           workspacePath: process.cwd(),
         };
-        const result = await handler.execute(task, context);
+        const result = await handler.execute(task, context, match);
         return result;
       } catch (err) {
         return { error: `Skill execution failed: ${err.message}` };
@@ -455,11 +366,10 @@ async function executeTool(name, args) {
     }
 
     case "list_skills": {
-      const skillsDir = findSkillsDir();
-      if (!skillsDir) {
-        return { error: "Skills directory not found." };
+      let skills = skillLoader.getResolvedSkills();
+      if (skills.length === 0) {
+        return { error: "No skills found." };
       }
-      let skills = loadSkillList(skillsDir);
       if (args.category) {
         skills = skills.filter(
           (s) => s.category.toLowerCase() === args.category.toLowerCase(),
@@ -479,8 +389,9 @@ async function executeTool(name, args) {
         skills: skills.map((s) => ({
           id: s.id,
           category: s.category,
+          source: s.source,
           hasHandler: s.hasHandler,
-          description: s.description.substring(0, 80),
+          description: (s.description || "").substring(0, 80),
         })),
       };
     }
@@ -654,7 +565,7 @@ Key behaviors:
 - When asked to create something, use write_file to create it
 - When asked to run/test something, use run_shell to execute it
 - When asked about files or code, use read_file and search_files to find information
-- You have 138 built-in skills (code-review, summarize, translate, refactor, etc.) — use list_skills to discover them and run_skill to execute them
+- You have multi-layer skills (built-in, marketplace, global, project-level) — use list_skills to discover them and run_skill to execute them
 - Always explain what you're doing and show results
 - Be concise but thorough
 
@@ -730,6 +641,9 @@ export async function startAgentRepl(options = {}) {
       logger.log(`  ${chalk.cyan("/provider")}   Show/change provider`);
       logger.log(`  ${chalk.cyan("/clear")}      Clear conversation`);
       logger.log(`  ${chalk.cyan("/compact")}    Keep only last 4 messages`);
+      logger.log(
+        `  ${chalk.cyan("/cowork")}     Multi-agent collaboration (debate, compare)`,
+      );
       logger.log(
         `  ${chalk.cyan("/plan")}       Enter plan mode (read-only analysis first)`,
       );
@@ -792,6 +706,97 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // Cowork commands
+    if (trimmed.startsWith("/cowork")) {
+      const coworkArgs = trimmed.slice(7).trim();
+      const [subCmd, ...rest] = coworkArgs.split(/\s+/);
+      const coworkInput = rest.join(" ");
+
+      if (!subCmd || subCmd === "help") {
+        logger.log(chalk.bold("\nCowork Commands:"));
+        logger.log(
+          `  ${chalk.cyan("/cowork debate <file>")}     Multi-perspective code review`,
+        );
+        logger.log(
+          `  ${chalk.cyan("/cowork compare <prompt>")}  A/B solution comparison`,
+        );
+        logger.log("");
+      } else if (subCmd === "debate" && coworkInput) {
+        try {
+          const { startDebate } =
+            await import("../lib/cowork/debate-review-cli.js");
+          let code = coworkInput;
+          let targetLabel = coworkInput;
+          const resolved = path.resolve(coworkInput);
+          if (fs.existsSync(resolved)) {
+            code = fs.readFileSync(resolved, "utf-8");
+            targetLabel = resolved;
+            if (code.length > 15000) {
+              code = code.substring(0, 15000) + "\n... (truncated)";
+            }
+          }
+          process.stdout.write(chalk.gray("\n  Running debate review...\n"));
+          const result = await startDebate({
+            target: targetLabel,
+            code,
+            llmOptions: { provider, model, baseUrl, apiKey },
+          });
+          for (const review of result.reviews) {
+            const vc =
+              review.verdict === "APPROVE"
+                ? chalk.green
+                : review.verdict === "REJECT"
+                  ? chalk.red
+                  : chalk.yellow;
+            process.stdout.write(
+              `  ${chalk.bold(review.role)}: ${vc(review.verdict)}\n`,
+            );
+          }
+          process.stdout.write(
+            `\n  ${chalk.bold("Verdict:")} ${result.verdict}  Consensus: ${result.consensusScore}%\n\n`,
+          );
+          // Add summary to conversation for context
+          messages.push({
+            role: "assistant",
+            content: `[Cowork Debate Result] ${result.verdict} (consensus: ${result.consensusScore}%)\n${result.summary.substring(0, 500)}`,
+          });
+        } catch (err) {
+          logger.error(`Debate failed: ${err.message}`);
+        }
+      } else if (subCmd === "compare" && coworkInput) {
+        try {
+          const { compare } =
+            await import("../lib/cowork/ab-comparator-cli.js");
+          process.stdout.write(chalk.gray("\n  Generating variants...\n"));
+          const result = await compare({
+            prompt: coworkInput,
+            llmOptions: { provider, model, baseUrl, apiKey },
+          });
+          for (const v of result.variants) {
+            process.stdout.write(
+              `  ${chalk.cyan(v.name)}: score ${v.totalScore}\n`,
+            );
+          }
+          process.stdout.write(
+            `\n  ${chalk.bold("Winner:")} ${chalk.green(result.winner)}\n\n`,
+          );
+          messages.push({
+            role: "assistant",
+            content: `[Cowork Compare Result] Winner: ${result.winner}. ${result.reason}`,
+          });
+        } catch (err) {
+          logger.error(`Compare failed: ${err.message}`);
+        }
+      } else {
+        logger.info(
+          "Usage: /cowork debate <file-or-topic> or /cowork compare <prompt>",
+        );
+      }
+
+      prompt();
+      return;
+    }
+
     // Plan mode commands
     if (trimmed.startsWith("/plan")) {
       const planManager = getPlanModeManager();