cclaw-cli 0.7.0 → 0.8.0

package/dist/install.js

@@ -17,7 +17,7 @@ import { contextMonitorScript, promptGuardScript, workflowGuardScript } from "./
 import { META_SKILL_NAME, usingCclawSkillMarkdown } from "./content/meta-skill.js";
 import { ARTIFACT_TEMPLATES, CURSOR_WORKFLOW_RULE_MDC, RULEBOOK_MARKDOWN, buildRulesJson } from "./content/templates.js";
 import { stageSkillFolder, stageSkillMarkdown } from "./content/skills.js";
-import { LANGUAGE_RULE_PACK_FOLDERS, LANGUAGE_RULE_PACK_GENERATORS, UTILITY_SKILL_FOLDERS, UTILITY_SKILL_MAP } from "./content/utility-skills.js";
+import { LANGUAGE_RULE_PACK_DIR, LANGUAGE_RULE_PACK_FILES, LANGUAGE_RULE_PACK_GENERATORS, LEGACY_LANGUAGE_RULE_PACK_FOLDERS, UTILITY_SKILL_FOLDERS, UTILITY_SKILL_MAP } from "./content/utility-skills.js";
 import { createInitialFlowState } from "./flow-state.js";
 import { ensureDir, exists, writeFileSafe } from "./fs-utils.js";
 import { ensureGitignore, removeGitignorePatterns } from "./gitignore.js";
@@ -183,13 +183,23 @@ async function writeSkills(projectRoot, config) {
         const generator = UTILITY_SKILL_MAP[folder];
         await writeFileSafe(runtimePath(projectRoot, "skills", folder, "SKILL.md"), generator());
     }
+    // Language rule packs live under .cclaw/rules/lang/<pack>.md. They are opt-in:
+    // only the packs listed in config.languageRulePacks are materialised. Any
+    // legacy per-language skill folders from v0.7.0 (.cclaw/skills/language-*)
+    // are cleaned up below so the new rules/lang layout is the only truth.
     const enabledPacks = config?.languageRulePacks ?? [];
     for (const pack of enabledPacks) {
-        const folder = LANGUAGE_RULE_PACK_FOLDERS[pack];
-        const generator = LANGUAGE_RULE_PACK_GENERATORS[folder];
-        if (!folder || !generator)
+        const fileName = LANGUAGE_RULE_PACK_FILES[pack];
+        const generator = LANGUAGE_RULE_PACK_GENERATORS[pack];
+        if (!fileName || !generator)
             continue;
-        await writeFileSafe(runtimePath(projectRoot, "skills", folder, "SKILL.md"), generator());
+        await writeFileSafe(runtimePath(projectRoot, ...LANGUAGE_RULE_PACK_DIR, fileName), generator());
+    }
+    for (const legacyFolder of LEGACY_LANGUAGE_RULE_PACK_FOLDERS) {
+        const legacyPath = runtimePath(projectRoot, "skills", legacyFolder);
+        if (await exists(legacyPath)) {
+            await fs.rm(legacyPath, { recursive: true, force: true });
+        }
     }
 }
 async function writeUtilityCommands(projectRoot) {
@@ -550,9 +560,13 @@ async function writeHooks(projectRoot, config) {
     }
 }
 async function ensureKnowledgeStore(projectRoot) {
-    const storePath = runtimePath(projectRoot, "knowledge.md");
+    const storePath = runtimePath(projectRoot, "knowledge.jsonl");
     if (!(await exists(storePath))) {
-        await writeFileSafe(storePath, "# Project Knowledge\n\n");
+        await writeFileSafe(storePath, "");
+    }
+    const legacyMdPath = runtimePath(projectRoot, "knowledge.md");
+    if (await exists(legacyMdPath)) {
+        await fs.rm(legacyMdPath, { force: true });
     }
 }
 async function ensureCustomSkillsScaffold(projectRoot) {

package/dist/policy.js

@@ -85,8 +85,9 @@ export async function policyChecks(projectRoot, options = {}) {
     // --- utility skill checks ---
     const runtimeFile = (relativePath) => `${RUNTIME_ROOT}/${relativePath}`;
     const utilitySkillChecks = [
-        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## Entry format", name: "utility_skill:learnings:entry_format" },
-        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "knowledge.jsonl", name: "utility_skill:learnings:jsonl_mirror" },
+        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "strict JSONL schema", name: "utility_skill:learnings:jsonl_schema" },
+        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "knowledge.jsonl", name: "utility_skill:learnings:jsonl_store" },
+        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "type, trigger, action, confidence, domain, stage, created, project", name: "utility_skill:learnings:field_order" },
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## Subcommands", name: "utility_skill:learnings:subcommands" },
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:learnings:hard_gate" },
         { file: runtimeFile("commands/learn.md"), needle: "## Subcommands", name: "utility_command:learn:subcommands" },

package/dist/runs.d.ts

@@ -56,11 +56,10 @@ export declare function ensureRunSystem(projectRoot: string, _options?: EnsureRu
 export declare function listRuns(projectRoot: string): Promise<CclawRunMeta[]>;
 export declare function archiveRun(projectRoot: string, featureName?: string): Promise<ArchiveRunResult>;
 /**
- * Counts active (non-superseded) knowledge entries.
- * An entry is a markdown H3 heading with the canonical timestamped format produced by
- * `learn add` / `learn curate`. Entries marked `Supersedes:` themselves are still active;
- * this helper does not currently follow supersession chains beyond raw count, which is
- * deliberate — the curator reads the file directly to make the soft-archive plan.
+ * Counts entries in the canonical JSONL knowledge store. An "active" entry is one
+ * non-empty line that parses as JSON with the required `type` field belonging to the
+ * allowed set. Malformed lines are ignored (not counted) but do not throw so that a
+ * hand-edited file cannot break doctor/archive flows.
  */
 export declare function countActiveKnowledgeEntries(text: string): number;
 export {};

package/dist/runs.js

@@ -407,7 +407,7 @@ export async function archiveRun(projectRoot, featureName) {
 }
 const KNOWLEDGE_SOFT_THRESHOLD = 50;
 async function readKnowledgeStats(projectRoot) {
-    const knowledgePath = path.join(projectRoot, RUNTIME_ROOT, "knowledge.md");
+    const knowledgePath = path.join(projectRoot, RUNTIME_ROOT, "knowledge.jsonl");
     let activeEntryCount = 0;
     if (await exists(knowledgePath)) {
         const text = await fs.readFile(knowledgePath, "utf8");
@@ -417,22 +417,30 @@ async function readKnowledgeStats(projectRoot) {
         activeEntryCount,
         softThreshold: KNOWLEDGE_SOFT_THRESHOLD,
         overThreshold: activeEntryCount > KNOWLEDGE_SOFT_THRESHOLD,
-        knowledgePath: `${RUNTIME_ROOT}/knowledge.md`
+        knowledgePath: `${RUNTIME_ROOT}/knowledge.jsonl`
     };
 }
 /**
- * Counts active (non-superseded) knowledge entries.
- * An entry is a markdown H3 heading with the canonical timestamped format produced by
- * `learn add` / `learn curate`. Entries marked `Supersedes:` themselves are still active;
- * this helper does not currently follow supersession chains beyond raw count, which is
- * deliberate — the curator reads the file directly to make the soft-archive plan.
+ * Counts entries in the canonical JSONL knowledge store. An "active" entry is one
+ * non-empty line that parses as JSON with the required `type` field belonging to the
+ * allowed set. Malformed lines are ignored (not counted) but do not throw so that a
+ * hand-edited file cannot break doctor/archive flows.
  */
 export function countActiveKnowledgeEntries(text) {
-    const lines = text.split(/\r?\n/);
+    const allowed = new Set(["rule", "pattern", "lesson", "compound"]);
     let count = 0;
-    for (const line of lines) {
-        if (/^###\s+\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z\s+\[(rule|pattern|lesson|compound)\]/u.test(line)) {
-            count += 1;
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (line.length === 0)
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (typeof parsed.type === "string" && allowed.has(parsed.type)) {
+                count += 1;
+            }
+        }
+        catch {
+            // Skip malformed lines silently; curation surfaces them separately.
         }
     }
     return count;

package/dist/types.d.ts

@@ -48,10 +48,10 @@ export interface VibyConfig {
     /** Default flow track for new runs (quick = shortened path, standard = full pipeline). */
     defaultTrack?: FlowTrack;
     /**
-     * Opt-in language rule packs. Each enabled pack materializes a matching utility
-     * skill under `.cclaw/skills/language-<id>/SKILL.md` on next `cclaw sync`. The
-     * meta-skill router loads the pack during review/tdd when the diff touches the
-     * language in question.
+     * Opt-in language rule packs. Each enabled pack materializes a matching rule
+     * file under `.cclaw/rules/lang/<id>.md` on the next `cclaw sync`. The
+     * meta-skill router loads the pack during review/tdd when the diff touches
+     * the language in question. Disabled packs have no on-disk footprint.
      */
     languageRulePacks?: LanguageRulePack[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {