skillwiki 0.6.0 → 0.6.1-beta.1

package/dist/cli.js

@@ -2780,7 +2780,7 @@ function extractSourceEntries(rawFm) {
   return entries;
 }
 var ERROR_ORDER = ["broken_wikilinks", "invalid_frontmatter", "raw_dedup", "broken_sources", "tag_not_in_taxonomy"];
-var WARNING_ORDER = ["raw_body_duplicate", "raw_subdirectory_duplicate", "index_incomplete", "index_link_format", "stale_page", "page_too_large", "log_rotate_needed", "orphans", "compound_refs", "legacy_citation_style", "orphaned_citations", "duplicate_frontmatter", "work_item_health", "orphaned_project_pages", "missing_overview", "missing_diagram"];
+var WARNING_ORDER = ["raw_body_duplicate", "raw_subdirectory_duplicate", "file_source_url", "index_incomplete", "index_link_format", "stale_page", "page_too_large", "log_rotate_needed", "orphans", "compound_refs", "legacy_citation_style", "orphaned_citations", "duplicate_frontmatter", "work_item_health", "orphaned_project_pages", "missing_overview", "missing_diagram"];
 var INFO_ORDER = ["bridges", "page_structure", "topic_map_recommended", "frontmatter_wikilink", "wikilink_citation", "missing_tldr", "stale_sections", "cli_refs"];
 async function runLint(input) {
   const buckets = {};
@@ -2865,6 +2865,16 @@ async function runLint(input) {
     if (subDirDupes.length > 0) {
       buckets.raw_subdirectory_duplicate = subDirDupes;
     }
+    const fileSourceUrlFlags = [];
+    for (const raw of scan.data.raw) {
+      const text = await readPage(raw);
+      const split = splitFrontmatter(text);
+      if (!split.ok) continue;
+      if (/^source_url:\s*file:\/\//m.test(split.data.rawFrontmatter)) {
+        fileSourceUrlFlags.push(raw.relPath);
+      }
+    }
+    if (fileSourceUrlFlags.length > 0) buckets.file_source_url = fileSourceUrlFlags;
     const legacyPages = [];
     const orphanedPages = [];
     const structFlags = [];
@@ -3304,6 +3314,45 @@ ${newBody}`;
         else delete buckets.wikilink_citation;
       }
     }
+    if (input.fix && fileSourceUrlFlags.length > 0) {
+      const FILE_FIXED = [];
+      for (const relPath of fileSourceUrlFlags) {
+        try {
+          const absPath = `${input.vault}/${relPath}`;
+          const raw = await readFile15(absPath, "utf8");
+          const parts = raw.split("---", 3);
+          if (parts.length < 3) {
+            unresolved.push(relPath);
+            continue;
+          }
+          const rawFm = parts[1];
+          const rest = parts[2];
+          const sourceMatch = rest.match(/^source:\s*"?(https?:\/\/[^\s\n"]+)"?\s*$/m);
+          if (!sourceMatch) {
+            unresolved.push(relPath);
+            continue;
+          }
+          const realUrl = sourceMatch[1];
+          const newRawFm = rawFm.replace(/^source_url:\s*file:\/\/[^\n]+/m, `source_url: ${realUrl}`);
+          const newContent = `---${newRawFm}---${rest}`;
+          const w = await safeWritePage(absPath, newContent);
+          if (!w.ok) {
+            unresolved.push(relPath);
+            continue;
+          }
+          FILE_FIXED.push(relPath);
+        } catch {
+          unresolved.push(relPath);
+        }
+      }
+      fixed.push(...FILE_FIXED);
+      if (FILE_FIXED.length > 0) {
+        const fixedSet = new Set(FILE_FIXED);
+        const remaining = fileSourceUrlFlags.filter((p) => !fixedSet.has(p));
+        if (remaining.length > 0) buckets.file_source_url = remaining;
+        else delete buckets.file_source_url;
+      }
+    }
   }
   const errorOut = ERROR_ORDER.flatMap((k) => buckets[k] ? [{ kind: k, items: buckets[k] }] : []);
   const warningOut = WARNING_ORDER.flatMap((k) => buckets[k] ? [{ kind: k, items: buckets[k] }] : []);
@@ -3681,7 +3730,7 @@ function detectFuseMount(vaultPath) {
           best = { point, fsType: `fuse.${match[1].split(":")[0] || "unknown"}` };
         }
       }
-      if (best) return best;
+      if (best) return { mountPoint: best.point, fsType: best.fsType };
     }
   } catch {
   }
@@ -4363,6 +4412,17 @@ async function runDoctor(input) {
 // src/commands/archive.ts
 import { rename as rename5, mkdir as mkdir8, readFile as readFile18, writeFile as writeFile9 } from "fs/promises";
 import { join as join25, dirname as dirname9 } from "path";
+function countWikilinks(body, slug) {
+  const escaped = slug.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`\\[\\[${escaped}(?:[|#][^\\]]*)?\\]\\]`, "g");
+  const m = body.match(re);
+  return m ? m.length : 0;
+}
+function arraysEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
 async function runArchive(input) {
   const scan = await scanVault(input.vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
@@ -4378,14 +4438,81 @@ async function runArchive(input) {
   }
   if (!relPath) return { exitCode: ExitCode.ARCHIVE_TARGET_NOT_FOUND, result: err("ARCHIVE_TARGET_NOT_FOUND", { page: input.page }) };
   if (relPath.startsWith("_archive/")) return { exitCode: ExitCode.ARCHIVE_ALREADY_ARCHIVED, result: err("ARCHIVE_ALREADY_ARCHIVED", { page: relPath }) };
+  const slug = relPath.replace(/\.md$/, "").split("/").pop();
   const archivePath = join25("_archive", relPath).replace(/\\/g, "/");
+  let cascade;
+  if (input.cascade) {
+    const wikilinkRefs = [];
+    const sourceArrayRefs = [];
+    for (const page of scan.data.typedKnowledge) {
+      if (page.relPath === relPath) continue;
+      const text = await readPage(page);
+      const split = splitFrontmatter(text);
+      if (!split.ok) continue;
+      const wl = countWikilinks(split.data.body, slug);
+      if (wl > 0) wikilinkRefs.push({ page: page.relPath, count: wl });
+      const fm = extractFrontmatter(text);
+      if (!fm.ok) continue;
+      const sources = fm.data.sources;
+      if (Array.isArray(sources) && sources.includes(relPath)) {
+        const before = sources.filter((s) => typeof s === "string");
+        const after = before.filter((s) => s !== relPath);
+        sourceArrayRefs.push({ page: page.relPath, sources_before: before, sources_after: after });
+      }
+    }
+    const indexRefs = [];
+    if (!isRaw) {
+      try {
+        const idx = await readFile18(join25(input.vault, "index.md"), "utf8");
+        idx.split("\n").forEach((line, i) => {
+          if (line.includes(`[[${slug}]]`)) indexRefs.push({ line: i + 1, text: line });
+        });
+      } catch (e) {
+        if (e instanceof Error && "code" in e && e.code !== "ENOENT") throw e;
+      }
+    }
+    cascade = { wikilink_refs: wikilinkRefs, index_refs: indexRefs, source_array_refs: sourceArrayRefs };
+  }
+  if (input.cascade && !input.apply) {
+    const summary = `DRY-RUN \u2014 would archive ${relPath}; ${cascade.wikilink_refs.length} wikilink ref(s), ${cascade.index_refs.length} index ref(s), ${cascade.source_array_refs.length} source array ref(s).`;
+    return {
+      exitCode: ExitCode.OK,
+      result: ok({
+        archived_from: relPath,
+        archived_to: archivePath,
+        index_updated: false,
+        applied: false,
+        cascade,
+        humanHint: summary
+      })
+    };
+  }
+  if (input.cascade && input.apply && cascade) {
+    for (const ref of cascade.source_array_refs) {
+      const absPath = join25(input.vault, ref.page);
+      const text = await readFile18(absPath, "utf8");
+      const split = splitFrontmatter(text);
+      if (!split.ok) continue;
+      const before = split.data.rawFrontmatter;
+      const newSourcesYaml = ref.sources_after.length === 0 ? "sources: []" : "sources:\n" + ref.sources_after.map((s) => `  - ${s}`).join("\n");
+      const fmRewritten = before.replace(
+        /^sources:\s*(?:\[[^\]]*\]|(?:\r?\n(?:\s*-\s.*))+)/m,
+        newSourcesYaml
+      );
+      if (fmRewritten === before) continue;
+      if (!arraysEqual(ref.sources_after, ref.sources_before)) {
+        await writeFile9(absPath, `---
+${fmRewritten}
+---${split.data.body}`, "utf8");
+      }
+    }
+  }
   await mkdir8(dirname9(join25(input.vault, archivePath)), { recursive: true });
   let indexUpdated = false;
   if (!isRaw) {
     const indexPath = join25(input.vault, "index.md");
     try {
       const idx = await readFile18(indexPath, "utf8");
-      const slug = relPath.replace(/\.md$/, "").split("/").pop();
       const originalLines = idx.split("\n");
       const filtered = originalLines.filter((l) => !l.includes(`[[${slug}]]`));
       if (filtered.length !== originalLines.length) {
@@ -4398,12 +4525,24 @@ async function runArchive(input) {
   }
   await rename5(join25(input.vault, relPath), join25(input.vault, archivePath));
   appendLastOp(input.vault, {
-    operation: "archive",
-    summary: `moved ${relPath} to ${archivePath}`,
+    operation: input.cascade ? "archive-cascade" : "archive",
+    summary: `moved ${relPath} to ${archivePath}${input.cascade ? ` (cascade: ${cascade?.source_array_refs.length ?? 0} source arrays updated)` : ""}`,
     files: [relPath],
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   });
-  return { exitCode: ExitCode.OK, result: ok({ archived_from: relPath, archived_to: archivePath, index_updated: indexUpdated, humanHint: `${relPath} -> ${archivePath}${indexUpdated ? " (index updated)" : ""}` }) };
+  const applied = input.cascade ? true : void 0;
+  const cascadeNote = input.cascade ? ` (cascade: ${cascade.source_array_refs.length} src arrays updated, ${cascade.wikilink_refs.length} wikilinks reported)` : "";
+  return {
+    exitCode: ExitCode.OK,
+    result: ok({
+      archived_from: relPath,
+      archived_to: archivePath,
+      index_updated: indexUpdated,
+      ...applied !== void 0 ? { applied } : {},
+      ...cascade ? { cascade } : {},
+      humanHint: `${relPath} -> ${archivePath}${indexUpdated ? " (index updated)" : ""}${cascadeNote}`
+    })
+  };
 }
 
 // src/commands/drift.ts
@@ -7310,10 +7449,10 @@ program.command("status [vault]").description("output vault diagnostics").option
     langEnvValue: process.env.WIKI_LANG
   }), v.vault);
 });
-program.command("archive <page> [vault]").description("archive a typed-knowledge or raw page").option("--wiki <name>", "wiki profile name").action(async (page, vault, opts) => {
+program.command("archive <page> [vault]").description("archive a typed-knowledge or raw page").option("--wiki <name>", "wiki profile name").option("--cascade", "scan vault for references (wikilinks + sources arrays); preview by default", false).option("--apply", "with --cascade: mutate sources arrays and archive (without --apply, --cascade is preview-only)", false).action(async (page, vault, opts) => {
   const v = await resolveVaultArg(vault, opts.wiki);
   if (!v.ok) emit({ exitCode: v.exitCode, result: v.payload });
-  else emit(await runArchive({ vault: v.vault, page }), v.vault);
+  else emit(await runArchive({ vault: v.vault, page, cascade: !!opts.cascade, apply: !!opts.apply }), v.vault);
 });
 program.command("drift [vault]").description("detect content drift in raw sources").option("--apply", "update sha256 in drifted sources").option("--new <date>", "list raw files ingested on/after this date (YYYY-MM-DD)").option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
   const v = await resolveVaultArg(vault, opts.wiki);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skillwiki",
-  "version": "0.6.0",
+  "version": "0.6.1-beta.1",
   "type": "module",
   "bin": {
     "skillwiki": "dist/cli.js"

package/skills/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "skillwiki",
-  "version": "0.6.0",
+  "version": "0.6.1-beta.1",
   "skills": "./",
   "description": "Project-aware Karpathy-style knowledge base for Claude Code: 18 prompt-only skills (wiki-*, proj-*, using-skillwiki) backed by the deterministic `skillwiki` CLI.",
   "author": {

package/skills/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "skillwiki",
-  "version": "0.6.0",
+  "version": "0.6.1-beta.1",
   "description": "Project-aware Karpathy-style knowledge base for Codex with 18 prompt-only skills backed by the deterministic skillwiki CLI.",
   "author": {
     "name": "karlorz",

package/skills/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skillwiki/skills",
-  "version": "0.6.0",
+  "version": "0.6.1-beta.1",
   "private": true,
   "files": [
     "wiki-*",

package/skills/wiki-sync/SKILL.md

@@ -1,7 +1,7 @@
 ---
-version: 0.3.0
+version: 0.6.1
 name: wiki-sync
-description: Safely sync the vault git repository — multi-session safe via advisory lockfile. Runs skillwiki sync status, then guides push or pull with lint guards and conflict resolution.
+description: Safely sync the vault git repository — multi-session safe via advisory lockfile. Handles rebase conflict storms from archive-commit × snapshot-stream patterns. Runs skillwiki sync status, then guides push or pull with lint guards and conflict resolution.
 ---
 # wiki-sync
 ## When This Skill Activates
@@ -143,6 +143,31 @@ When `git pull --rebase` reports `CONFLICT (modify/delete)`:
    - `git -C "$VAULT" add <path>` — keep the local restoration (rebase continues)
 4. `git -C "$VAULT" rebase --continue`.
 
+### Rebase conflict storm (archive commits × snapshot stream)
+
+When many local archive-only commits (e.g., `archive: moved X to _archive/`) are rebased over an origin/main that receives frequent snapshot commits (e.g., sg01 `Snapshot YYYYMMDD_HHMMSS`), every archive commit re-triggers the same content conflicts on shared files (`log.md`, `knowledge.md`, `spec.md`). This is predictable and can be resolved systematically.
+
+**Detection**: 3+ consecutive rebase stops on commits whose message matches `^archive: moved`.
+
+**Resolution**: For each archive commit during the storm:
+
+```bash
+# Apply --ours to all conflicting files (keep HEAD = origin/main + snapshots)
+for f in $(git -C "$VAULT" diff --name-only --diff-filter=U); do
+  git -C "$VAULT" checkout --ours "$f" && git -C "$VAULT" add "$f"
+done
+git -C "$VAULT" rebase --continue
+```
+
+**After the storm passes** (non-archive commits or clean rebase), pop the stash and handle any remaining conflicts per the normal Conflict Resolution sections above.
+
+**Prevention**:
+- Sync more frequently — don't let local fall >5 commits behind origin/main
+- Bundle archive commits — `skillwiki archive --batch` groups 5-10 transcript archives into one commit, reducing rebase surface
+- For vaults with snapshot cron, prefer smaller, more frequent syncs over large batch rebases
+
+See `concepts/wiki-sync-rebase-conflict-storm-pattern.md` for detailed analysis.
+
 ## Multi-device coordination
 When the user mentions editing from Obsidian desktop and Claude Code on a server (or any two-device setup):
 - Recommend pulling before every editing session on each device.