kc-beta 0.1.1 → 0.1.2

package/src/agent/skill-loader.js

@@ -0,0 +1,139 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const BUNDLED_SKILLS_DIR = path.resolve(__dirname, "../../template/skills");
+
+/**
+ * Discover and index meta skills from template/skills/.
+ * Follows Claude Code's pattern: skills are NOT dumped into the system prompt.
+ * Instead, a brief index (name + description) is injected into context.
+ * The agent reads full SKILL.md content on demand via workspace_file or sandbox_exec.
+ *
+ * Skills are organized as:
+ *   template/skills/{lang}/meta-meta/  — System architecture methodology
+ *   template/skills/{lang}/meta/       — Verification domain methodology
+ *   template/skills/{lang}/skill-creator/ — Anthropic's official skill creation toolkit
+ */
+export class SkillLoader {
+  /**
+   * @param {string} [language] - "en" or "zh"
+   * @param {string} [skillsDir] - Override skills directory (default: bundled template)
+   */
+  constructor(language = "en", skillsDir) {
+    this._lang = language;
+    this._skillsDir = skillsDir || BUNDLED_SKILLS_DIR;
+    this._index = null;
+  }
+
+  /**
+   * Build the skill index by scanning SKILL.md frontmatter.
+   * Cached after first call.
+   * @returns {Array<{name: string, description: string, category: string, path: string}>}
+   */
+  getIndex() {
+    if (this._index) return this._index;
+
+    this._index = [];
+    const langDir = path.join(this._skillsDir, this._lang);
+    if (!fs.existsSync(langDir)) return this._index;
+
+    for (const category of ["meta-meta", "meta", "skill-creator"]) {
+      const catDir = path.join(langDir, category);
+      if (!fs.existsSync(catDir)) continue;
+
+      // skill-creator is a single skill, not a directory of skills
+      const skillMd = path.join(catDir, "SKILL.md");
+      if (fs.existsSync(skillMd)) {
+        const { name, description } = this._parseFrontmatter(skillMd);
+        if (name) {
+          this._index.push({
+            name: name || category,
+            description: description || "",
+            category,
+            path: path.relative(this._skillsDir, catDir),
+          });
+        }
+      }
+
+      // Check subdirectories (meta-meta/bootstrap-workspace/, etc.)
+      for (const entry of fs.readdirSync(catDir, { withFileTypes: true })) {
+        if (!entry.isDirectory()) continue;
+        const subSkillMd = path.join(catDir, entry.name, "SKILL.md");
+        if (!fs.existsSync(subSkillMd)) continue;
+
+        const { name, description } = this._parseFrontmatter(subSkillMd);
+        this._index.push({
+          name: name || entry.name,
+          description: description || "",
+          category,
+          path: path.relative(this._skillsDir, path.join(catDir, entry.name)),
+        });
+      }
+    }
+
+    return this._index;
+  }
+
+  /**
+   * Format the skill index for injection into agent context.
+   * Brief listing — agent reads full content on demand.
+   * @returns {string}
+   */
+  formatForContext() {
+    const index = this.getIndex();
+    if (index.length === 0) return "";
+
+    const metaMeta = index.filter((s) => s.category === "meta-meta");
+    const meta = index.filter((s) => s.category === "meta");
+    const other = index.filter((s) => s.category !== "meta-meta" && s.category !== "meta");
+
+    const lines = ["## Available Methodology Skills",
+      "Read full skill content from the skills/ directory when needed.\n"];
+
+    if (metaMeta.length) {
+      lines.push("**System Architecture (meta-meta):**");
+      for (const s of metaMeta) {
+        lines.push(`- **${s.name}**: ${s.description.slice(0, 120)}`);
+      }
+      lines.push("");
+    }
+
+    if (meta.length) {
+      lines.push("**Verification Methodology (meta):**");
+      for (const s of meta) {
+        lines.push(`- **${s.name}**: ${s.description.slice(0, 120)}`);
+      }
+      lines.push("");
+    }
+
+    if (other.length) {
+      lines.push("**Toolkits:**");
+      for (const s of other) {
+        lines.push(`- **${s.name}**: ${s.description.slice(0, 120)}`);
+      }
+    }
+
+    return lines.join("\n");
+  }
+
+  /**
+   * Parse YAML frontmatter from a SKILL.md file.
+   * Only extracts name and description — lightweight.
+   */
+  _parseFrontmatter(filePath) {
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      const match = content.match(/^---\n([\s\S]*?)\n---/);
+      if (!match) return {};
+
+      const frontmatter = match[1];
+      const name = frontmatter.match(/^name:\s*(.+)$/m)?.[1]?.trim() || "";
+      const description = frontmatter.match(/^description:\s*(.+)$/m)?.[1]?.trim() || "";
+      return { name, description };
+    } catch {
+      return {};
+    }
+  }
+}

package/src/agent/tools/tier-downgrade.js

@@ -72,14 +72,23 @@ export class TierDowngradeTool extends BaseTool {
       }
     }
 
-    const recommend = targetAcc >= threshold && delta <= 0.05 ? "downgrade" : "keep_current";
+    // Read tier tolerance from .env (default from onboarding config)
+    let tolerance = 0.05;
+    if (fs.existsSync(envPath)) {
+      for (const line of fs.readFileSync(envPath, "utf-8").split("\n")) {
+        if (line.startsWith("TIER_TOLERANCE=")) {
+          try { tolerance = parseFloat(line.split("=")[1].trim()); }
+          catch { /* ignore */ }
+        }
+      }
+    }
 
     const report = {
       rule_id: ruleId, current_tier: currentTier, target_tier: targetTier,
       current_accuracy: Math.round(currentAcc * 1000) / 1000,
       target_accuracy: Math.round(targetAcc * 1000) / 1000,
       accuracy_delta: Math.round(delta * 1000) / 1000,
-      threshold, recommendation: recommend, test_count: testInputs.length,
+      threshold, tolerance, test_count: testInputs.length,
     };
     return new ToolResult(JSON.stringify(report, null, 2));
   }

package/src/cli/onboard.js

@@ -160,6 +160,15 @@ export async function onboard() {
   const accuracy = parseFloat(await ask(rl, `  ${CYAN}${t.accuracy}${RESET}`, defaultAcc));
   console.log();
 
+  // Advanced thresholds (Enter to keep defaults)
+  const advLabel = lang === "zh" ? "高级阈值" : "Advanced Thresholds";
+  const skipHint = lang === "zh" ? "回车使用默认值" : "Enter to keep defaults";
+  console.log(`  ${CYAN}${advLabel}${RESET} ${DIM}(${skipHint})${RESET}`);
+  const systemicThreshold = parseFloat(await ask(rl, `    ${lang === "zh" ? "系统性问题阈值" : "Systemic threshold"}`, existing.systemic_threshold?.toString() || "0.10"));
+  const spotCheckRate = parseFloat(await ask(rl, `    ${lang === "zh" ? "抽查比率" : "Spot-check rate"}`, existing.spot_check_rate?.toString() || "0.10"));
+  const tierTolerance = parseFloat(await ask(rl, `    ${lang === "zh" ? "降级容差" : "Tier downgrade tolerance"}`, existing.tier_tolerance?.toString() || "0.05"));
+  console.log();
+
   rl.close();
 
   const config = {
@@ -170,6 +179,9 @@ export async function onboard() {
     conductor_model: model,
     tiers,
     accuracy_threshold: accuracy,
+    systemic_threshold: systemicThreshold,
+    spot_check_rate: spotCheckRate,
+    tier_tolerance: tierTolerance,
   };
 
   fs.mkdirSync(CONFIG_DIR, { recursive: true });

package/src/config.js

@@ -81,6 +81,11 @@ export function loadSettings(workspacePath) {
     skillAccuracy: parseFloat(env.SKILL_ACCURACY || gc.accuracy_threshold?.toString() || "0.9"),
     workflowAccuracy: parseFloat(env.WORKFLOW_ACCURACY || "0.9"),
 
+    // Advanced thresholds (from onboarding or .env)
+    systemicThreshold: parseFloat(env.SYSTEMIC_THRESHOLD || gc.systemic_threshold?.toString() || "0.10"),
+    spotCheckRate: parseFloat(env.SPOT_CHECK_RATE || gc.spot_check_rate?.toString() || "0.10"),
+    tierTolerance: parseFloat(env.TIER_TOLERANCE || gc.tier_tolerance?.toString() || "0.05"),
+
     // Evolution
     maxIterations: parseInt(env.MAX_ITERATIONS || "20", 10),
     monitorFrequency: env.MONITOR_FREQUENCY || "mid",