caveat-cli 0.2.0 → 0.3.0

package/dist/index.js

@@ -9761,49 +9761,49 @@ var require_fast_uri = __commonJS({
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base2, relative2, options2, skipNormalization) {
+    function resolveComponent(base2, relative3, options2, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base2 = parse4(serialize(base2, options2), options2);
-        relative2 = parse4(serialize(relative2, options2), options2);
+        relative3 = parse4(serialize(relative3, options2), options2);
       }
       options2 = options2 || {};
-      if (!options2.tolerant && relative2.scheme) {
-        target.scheme = relative2.scheme;
-        target.userinfo = relative2.userinfo;
-        target.host = relative2.host;
-        target.port = relative2.port;
-        target.path = removeDotSegments(relative2.path || "");
-        target.query = relative2.query;
+      if (!options2.tolerant && relative3.scheme) {
+        target.scheme = relative3.scheme;
+        target.userinfo = relative3.userinfo;
+        target.host = relative3.host;
+        target.port = relative3.port;
+        target.path = removeDotSegments(relative3.path || "");
+        target.query = relative3.query;
       } else {
-        if (relative2.userinfo !== void 0 || relative2.host !== void 0 || relative2.port !== void 0) {
-          target.userinfo = relative2.userinfo;
-          target.host = relative2.host;
-          target.port = relative2.port;
-          target.path = removeDotSegments(relative2.path || "");
-          target.query = relative2.query;
+        if (relative3.userinfo !== void 0 || relative3.host !== void 0 || relative3.port !== void 0) {
+          target.userinfo = relative3.userinfo;
+          target.host = relative3.host;
+          target.port = relative3.port;
+          target.path = removeDotSegments(relative3.path || "");
+          target.query = relative3.query;
         } else {
-          if (!relative2.path) {
+          if (!relative3.path) {
             target.path = base2.path;
-            if (relative2.query !== void 0) {
-              target.query = relative2.query;
+            if (relative3.query !== void 0) {
+              target.query = relative3.query;
             } else {
               target.query = base2.query;
             }
           } else {
-            if (relative2.path[0] === "/") {
-              target.path = removeDotSegments(relative2.path);
+            if (relative3.path[0] === "/") {
+              target.path = removeDotSegments(relative3.path);
             } else {
               if ((base2.userinfo !== void 0 || base2.host !== void 0 || base2.port !== void 0) && !base2.path) {
-                target.path = "/" + relative2.path;
+                target.path = "/" + relative3.path;
               } else if (!base2.path) {
-                target.path = relative2.path;
+                target.path = relative3.path;
               } else {
-                target.path = base2.path.slice(0, base2.path.lastIndexOf("/") + 1) + relative2.path;
+                target.path = base2.path.slice(0, base2.path.lastIndexOf("/") + 1) + relative3.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative2.query;
+            target.query = relative3.query;
           }
           target.userinfo = base2.userinfo;
           target.host = base2.host;
@@ -9811,7 +9811,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base2.scheme;
       }
-      target.fragment = relative2.fragment;
+      target.fragment = relative3.fragment;
       return target;
     }
     function equal(uriA, uriB, options2) {
@@ -16139,10 +16139,12 @@ function resolvePaths(caveatHome, knowledgeRepo, userHome) {
 
 // ../../packages/core/dist/config.js
 import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+var SHARED_REPO_URL = "https://github.com/kitepon-rgb/caveats-quo";
 var DEFAULT_CONFIG = {
   knowledgeRepo: "own",
   semverKeys: ["driver", "cuda", "node"],
-  communitySources: []
+  communitySources: [],
+  sharedRepo: SHARED_REPO_URL
 };
 function loadConfig(userConfigPath) {
   const userCfg = existsSync5(userConfigPath) ? JSON.parse(readFileSync4(userConfigPath, "utf-8")) : {};
@@ -21251,7 +21253,7 @@ var stdoutLogger = {
 };
 
 // src/commands/init.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync4 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readdirSync as readdirSync4, writeFileSync as writeFileSync5 } from "node:fs";
 import { join as join9 } from "node:path";
 
 // src/claudeInstall.ts
@@ -21403,7 +21405,21 @@ function uninstallClaudeIntegration(opts) {
 }
 
 // src/commands/init.ts
-function runInit(ctx, opts = { skipClaude: false, dryRun: false }) {
+var KNOWLEDGE_GITIGNORE = [
+  "# Never commit entries flagged private (visibility: private is enforced by the",
+  "# pre-commit gate, but this is a filename-level backup guard).",
+  "*.private.md",
+  "",
+  "# Obsidian per-user config: workspace layout, theme, plugin state, cache.",
+  ".obsidian/",
+  "",
+  "# community/ is a local cache of shallow-cloned third-party caveat repos",
+  "# (populated by `caveat community add`). Each contains its own .git and is not",
+  "# part of this repo's tracked knowledge.",
+  "community/",
+  ""
+].join("\n");
+async function runInit(ctx, opts = { skipClaude: false, skipShared: false, dryRun: false }) {
   ensureUserConfig(ctx.userConfigPath);
   ctx.logger.info(`user config: ${ctx.userConfigPath}`);
   if (!existsSync8(ctx.paths.knowledgeRepo)) {
@@ -21413,8 +21429,23 @@ function runInit(ctx, opts = { skipClaude: false, dryRun: false }) {
   } else {
     ctx.logger.info(`knowledge repo: ${ctx.paths.knowledgeRepo}`);
   }
+  const gitignorePath = join9(ctx.paths.knowledgeRepo, ".gitignore");
+  if (!existsSync8(gitignorePath)) {
+    writeFileSync5(gitignorePath, KNOWLEDGE_GITIGNORE, "utf-8");
+    ctx.logger.info(`.gitignore created: ${gitignorePath}`);
+  }
   const db = openDb({ path: ctx.paths.dbPath, logger: ctx.logger });
-  db.close();
+  try {
+    if (!opts.skipShared && !opts.dryRun) {
+      await subscribeSharedRepo(ctx, db);
+    } else if (opts.skipShared) {
+      ctx.logger.info("shared community DB subscription skipped (--skip-shared)");
+    } else if (opts.dryRun) {
+      ctx.logger.info(`[dry-run] would subscribe to shared community DB: ${ctx.config.sharedRepo}`);
+    }
+  } finally {
+    db.close();
+  }
   ctx.logger.info(`db initialized: ${ctx.paths.dbPath}`);
   if (opts.skipClaude) {
     ctx.logger.info("Claude Code integration skipped (--skip-claude)");
@@ -21434,6 +21465,52 @@ function runInit(ctx, opts = { skipClaude: false, dryRun: false }) {
   });
   reportInstallResult(ctx, result, opts.dryRun);
 }
+async function subscribeSharedRepo(ctx, db) {
+  const url = ctx.config.sharedRepo;
+  const validation = validateCommunityUrl(url);
+  if (!validation.valid) {
+    ctx.logger.warn(
+      `sharedRepo is not a valid GitHub URL \u2014 skipping: ${validation.reason}`
+    );
+    return;
+  }
+  const handle = validation.handle;
+  const target = join9(ctx.paths.communityDir, handle);
+  if (!existsSync8(target)) {
+    if (!existsSync8(ctx.paths.communityDir)) {
+      mkdirSync4(ctx.paths.communityDir, { recursive: true });
+    }
+    try {
+      await communityAdd({
+        url,
+        communityDir: ctx.paths.communityDir,
+        logger: ctx.logger
+      });
+      ctx.logger.info(`shared community DB subscribed: ${url} \u2192 community/${handle}/`);
+    } catch (err) {
+      ctx.logger.warn(
+        `shared community DB subscription failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return;
+    }
+  } else {
+    ctx.logger.info(`shared community DB already subscribed: community/${handle}/`);
+  }
+  if (existsSync8(ctx.paths.communityDir)) {
+    rebuildAll(db);
+    if (existsSync8(ctx.paths.entriesDir)) {
+      scanSource({ db, source: "own", entriesRoot: ctx.paths.entriesDir });
+    }
+    for (const entry of readdirSync4(ctx.paths.communityDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const source = `community/${entry.name}`;
+      const root = join9(ctx.paths.communityDir, entry.name, "entries");
+      if (!existsSync8(root)) continue;
+      const result = scanSource({ db, source, entriesRoot: root });
+      ctx.logger.info(`indexed ${source}: +${result.added}`);
+    }
+  }
+}
 function runUninstall(ctx, opts) {
   const cliScriptPath = process.argv[1];
   if (!cliScriptPath) {
@@ -21478,7 +21555,7 @@ function reportInstallResult(ctx, result, dryRun) {
 }
 
 // src/commands/indexCmd.ts
-import { existsSync as existsSync9, readdirSync as readdirSync4, mkdirSync as mkdirSync5 } from "node:fs";
+import { existsSync as existsSync9, readdirSync as readdirSync5, mkdirSync as mkdirSync5 } from "node:fs";
 import { dirname as dirname5, join as join10 } from "node:path";
 function runIndex(ctx, opts) {
   const dbDir = dirname5(ctx.paths.dbPath);
@@ -21496,7 +21573,7 @@ function runIndex(ctx, opts) {
       ctx.logger.warn(`entries dir not found: ${ctx.paths.entriesDir}`);
     }
     if (existsSync9(ctx.paths.communityDir)) {
-      for (const entry of readdirSync4(ctx.paths.communityDir, { withFileTypes: true })) {
+      for (const entry of readdirSync5(ctx.paths.communityDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         const source = `community/${entry.name}`;
         const root = join10(ctx.paths.communityDir, entry.name, "entries");
@@ -30005,12 +30082,12 @@ function createDetailRoute(ctx) {
 }
 
 // ../web/dist/routes/community.js
-import { existsSync as existsSync10, readdirSync as readdirSync5, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync10, readdirSync as readdirSync6, statSync as statSync4 } from "node:fs";
 import { join as join12 } from "node:path";
 function listCommunity(communityDir, db) {
   if (!existsSync10(communityDir)) return [];
   const handles = [];
-  for (const entry of readdirSync5(communityDir, { withFileTypes: true })) {
+  for (const entry of readdirSync6(communityDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     const handlePath = join12(communityDir, entry.name);
     const countRow = db.prepare("SELECT COUNT(*) AS n FROM entries WHERE source = ?").get(`community/${entry.name}`);
@@ -44629,6 +44706,263 @@ async function runHook(name) {
   process.exit(0);
 }
 
+// src/commands/pull.ts
+import { existsSync as existsSync11, readdirSync as readdirSync7 } from "node:fs";
+import { join as join14 } from "node:path";
+async function runPull(ctx) {
+  if (!existsSync11(ctx.paths.communityDir)) {
+    ctx.logger.info(
+      "no community repos yet \u2014 did you run `caveat init`? You can also `caveat community add <url>` manually."
+    );
+    return;
+  }
+  const results = await communityPull({
+    communityDir: ctx.paths.communityDir,
+    logger: ctx.logger
+  });
+  for (const r2 of results) {
+    if (r2.status === "ok") {
+      ctx.logger.info(`${r2.handle}: pulled`);
+    } else {
+      ctx.logger.warn(`${r2.handle}: FAILED \u2014 ${r2.message ?? "unknown"}`);
+    }
+  }
+  const db = openDb({ path: ctx.paths.dbPath, logger: ctx.logger });
+  try {
+    rebuildAll(db);
+    if (existsSync11(ctx.paths.entriesDir)) {
+      const ownResult = scanSource({ db, source: "own", entriesRoot: ctx.paths.entriesDir });
+      ctx.logger.info(`own: +${ownResult.added}`);
+    }
+    for (const entry of readdirSync7(ctx.paths.communityDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const source = `community/${entry.name}`;
+      const root = join14(ctx.paths.communityDir, entry.name, "entries");
+      if (!existsSync11(root)) continue;
+      const scan = scanSource({ db, source, entriesRoot: root });
+      ctx.logger.info(`${source}: +${scan.added}`);
+    }
+  } finally {
+    db.close();
+  }
+}
+
+// src/commands/push.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import {
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync12,
+  mkdirSync as mkdirSync6,
+  readdirSync as readdirSync8,
+  readFileSync as readFileSync6,
+  statSync as statSync5
+} from "node:fs";
+import { dirname as dirname6, join as join15, relative as relative2 } from "node:path";
+async function runPush(ctx, opts) {
+  const ghOk = checkGhAvailable(ctx);
+  if (!ghOk) return;
+  const sharedValidation = validateCommunityUrl(ctx.config.sharedRepo);
+  if (!sharedValidation.valid) {
+    ctx.logger.error(
+      `sharedRepo is not a valid GitHub URL: ${ctx.config.sharedRepo} (${sharedValidation.reason})`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const [sharedOwner, sharedName] = parseOwnerRepo(ctx.config.sharedRepo);
+  if (!sharedOwner || !sharedName) {
+    ctx.logger.error(`cannot parse sharedRepo owner/repo: ${ctx.config.sharedRepo}`);
+    process.exitCode = 1;
+    return;
+  }
+  const owned = findOwnedEntry(ctx, opts.id);
+  if (!owned) {
+    ctx.logger.error(
+      `entry not found in ${ctx.paths.entriesDir}: id=${opts.id}. List with \`caveat list\`, or write the md file and index first.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const ghUser = resolveGhUser(ctx);
+  if (!ghUser) return;
+  if (opts.dryRun) {
+    ctx.logger.info(`[dry-run] would push entry ${owned.id} (${owned.title})`);
+    ctx.logger.info(`[dry-run]   1. fork ${sharedOwner}/${sharedName} as ${ghUser}/${sharedName}`);
+    ctx.logger.info(`[dry-run]   2. clone fork \u2192 ${forkStagingDir(ctx)}`);
+    ctx.logger.info(`[dry-run]   3. copy entry \u2192 entries/${owned.relPath}`);
+    ctx.logger.info("[dry-run]   4. commit, push branch, open PR against main");
+    return;
+  }
+  ensureFork(ctx, sharedOwner, sharedName, ghUser);
+  const stagingDir = forkStagingDir(ctx);
+  ensureStagingClone(ctx, stagingDir, ghUser, sharedName, sharedOwner);
+  const branch = `caveat-push-${owned.id}-${Date.now().toString(36)}`;
+  run(ctx, "git", ["checkout", "-b", branch], { cwd: stagingDir });
+  const destPath = join15(stagingDir, "entries", owned.relPath);
+  mkdirSync6(dirname6(destPath), { recursive: true });
+  copyFileSync2(owned.absPath, destPath);
+  run(ctx, "git", ["add", join15("entries", owned.relPath)], { cwd: stagingDir });
+  const verb = existsInUpstream(stagingDir, "entries/" + owned.relPath) ? "update" : "add";
+  const commitMsg = `${verb}: ${owned.title}`;
+  run(ctx, "git", ["commit", "-m", commitMsg], { cwd: stagingDir });
+  run(ctx, "git", ["push", "--set-upstream", "origin", branch], { cwd: stagingDir });
+  const prTitle = `${verb}: ${owned.title}`;
+  const prBody = [
+    `Contribution of caveat \`${owned.id}\` via \`caveat push\`.`,
+    "",
+    `- entry path: \`entries/${owned.relPath}\``,
+    `- action: ${verb}`,
+    "",
+    "Merged PRs will appear in subscribers' repos on their next `caveat pull`."
+  ].join("\n");
+  const prResult = runClaim(
+    ctx,
+    "gh",
+    [
+      "pr",
+      "create",
+      "--repo",
+      `${sharedOwner}/${sharedName}`,
+      "--base",
+      "main",
+      "--head",
+      `${ghUser}:${branch}`,
+      "--title",
+      prTitle,
+      "--body",
+      prBody
+    ],
+    { cwd: stagingDir }
+  );
+  if (prResult.status === 0) {
+    const url = prResult.stdout.trim();
+    ctx.logger.info(`PR opened: ${url}`);
+    ctx.logger.info(
+      "Once merged, other subscribers will see your entry after their next `caveat pull`."
+    );
+  } else {
+    ctx.logger.error(
+      `gh pr create failed: ${(prResult.stderr || prResult.stdout || "").trim()}`
+    );
+    process.exitCode = 1;
+  }
+}
+function checkGhAvailable(ctx) {
+  const r2 = spawnSync2("gh", ["--version"], { encoding: "utf-8", shell: true });
+  if (r2.status !== 0) {
+    ctx.logger.error(
+      "gh (GitHub CLI) is required for `caveat push`. Install: https://cli.github.com/"
+    );
+    process.exitCode = 1;
+    return false;
+  }
+  const auth = spawnSync2("gh", ["auth", "status"], { encoding: "utf-8", shell: true });
+  if (auth.status !== 0) {
+    ctx.logger.error("gh is not authenticated. Run `gh auth login` first.");
+    process.exitCode = 1;
+    return false;
+  }
+  return true;
+}
+function resolveGhUser(ctx) {
+  const r2 = spawnSync2("gh", ["api", "user", "--jq", ".login"], {
+    encoding: "utf-8",
+    shell: true
+  });
+  if (r2.status !== 0) {
+    ctx.logger.error(`gh api user failed: ${(r2.stderr || r2.stdout).trim()}`);
+    process.exitCode = 1;
+    return void 0;
+  }
+  return r2.stdout.trim();
+}
+function parseOwnerRepo(url) {
+  const m = /^https:\/\/github\.com\/([^/]+)\/([^/]+?)(\.git)?\/?$/.exec(url);
+  if (!m) return [void 0, void 0];
+  return [m[1], m[2]];
+}
+function findOwnedEntry(ctx, id) {
+  if (!existsSync12(ctx.paths.entriesDir)) return void 0;
+  for (const categoryDirent of readdirSync8(ctx.paths.entriesDir, { withFileTypes: true })) {
+    if (!categoryDirent.isDirectory()) continue;
+    const categoryDir = join15(ctx.paths.entriesDir, categoryDirent.name);
+    for (const fileDirent of readdirSync8(categoryDir, { withFileTypes: true })) {
+      if (!fileDirent.isFile() || !fileDirent.name.endsWith(".md")) continue;
+      const absPath = join15(categoryDir, fileDirent.name);
+      const raw2 = readFileSync6(absPath, "utf-8");
+      try {
+        const parsed = parseMarkdown(raw2);
+        if (parsed.frontmatter.id === id) {
+          const relPath = relative2(ctx.paths.entriesDir, absPath).replace(/\\/g, "/");
+          return {
+            id,
+            title: parsed.frontmatter.title,
+            absPath,
+            relPath
+          };
+        }
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function forkStagingDir(ctx) {
+  return join15(ctx.caveatHome, "push-fork");
+}
+function ensureFork(ctx, owner, repo, ghUser) {
+  const r2 = spawnSync2(
+    "gh",
+    ["repo", "fork", `${owner}/${repo}`, "--clone=false", "--remote=false"],
+    { encoding: "utf-8", shell: true }
+  );
+  if (r2.status !== 0 && !(r2.stderr || "").includes("already exists")) {
+    ctx.logger.warn(`gh repo fork stderr: ${r2.stderr.trim()}`);
+  }
+  void ghUser;
+}
+function ensureStagingClone(ctx, stagingDir, ghUser, sharedName, upstreamOwner) {
+  if (!existsSync12(stagingDir)) {
+    mkdirSync6(dirname6(stagingDir), { recursive: true });
+    const forkUrl = `https://github.com/${ghUser}/${sharedName}.git`;
+    run(ctx, "git", ["clone", "--depth", "30", forkUrl, stagingDir]);
+    run(ctx, "git", ["remote", "add", "upstream", `https://github.com/${upstreamOwner}/${sharedName}.git`], {
+      cwd: stagingDir
+    });
+  } else {
+    run(ctx, "git", ["checkout", "main"], { cwd: stagingDir });
+    run(ctx, "git", ["fetch", "upstream", "main"], { cwd: stagingDir });
+    run(ctx, "git", ["reset", "--hard", "upstream/main"], { cwd: stagingDir });
+    run(ctx, "git", ["push", "origin", "main", "--force-with-lease"], { cwd: stagingDir });
+  }
+}
+function existsInUpstream(stagingDir, relFromRoot) {
+  return existsSync12(join15(stagingDir, relFromRoot));
+}
+function run(ctx, command, args, opts = {}) {
+  const r2 = spawnSync2(command, args, {
+    encoding: "utf-8",
+    cwd: opts.cwd,
+    shell: true
+  });
+  if (r2.status !== 0) {
+    const msg = (r2.stderr || r2.stdout || "unknown").trim();
+    throw new Error(`${command} ${args.join(" ")} failed: ${msg}`);
+  }
+}
+function runClaim(ctx, command, args, opts = {}) {
+  const r2 = spawnSync2(command, args, {
+    encoding: "utf-8",
+    cwd: opts.cwd,
+    shell: true
+  });
+  return {
+    status: r2.status,
+    stdout: typeof r2.stdout === "string" ? r2.stdout : "",
+    stderr: typeof r2.stderr === "string" ? r2.stderr : ""
+  };
+}
+
 // src/commands/community.ts
 async function runCommunityAdd(ctx, url) {
   try {
@@ -44681,12 +45015,16 @@ function runCommunityList(ctx) {
 
 // src/index.ts
 var program = new Command();
-program.name("caveat").description("External spec gotcha knowledge base CLI").version("0.2.0");
+program.name("caveat").description("External spec gotcha knowledge base CLI").version("0.3.0");
 program.command("init").description(
-  "Initialize ~/.caveatrc.json, ~/.caveat/, and register Claude Code integration"
-).option("--skip-claude", "skip Claude Code MCP + hook registration", false).option("--dry-run", "show planned changes without writing", false).action((opts) => {
+  "Initialize ~/.caveatrc.json, ~/.caveat/, subscribe to the shared community DB, and register Claude Code integration"
+).option("--skip-claude", "skip Claude Code MCP + hook registration", false).option("--skip-shared", "skip subscribing to the shared community DB", false).option("--dry-run", "show planned changes without writing", false).action(async (opts) => {
   const ctx = buildContext(stdoutLogger);
-  runInit(ctx, { skipClaude: opts.skipClaude, dryRun: opts.dryRun });
+  await runInit(ctx, {
+    skipClaude: opts.skipClaude,
+    skipShared: opts.skipShared,
+    dryRun: opts.dryRun
+  });
 });
 program.command("uninstall").description("Remove Claude Code MCP server and hooks registered by `caveat init`").option("--dry-run", "show planned changes without writing", false).action((opts) => {
   const ctx = buildContext(stdoutLogger);
@@ -44719,6 +45057,16 @@ program.command("stats").description("Show aggregate stats").action(() => {
   const ctx = buildContext(stdoutLogger);
   runStats(ctx);
 });
+program.command("pull").description(
+  "Refresh all subscribed community repos (incl. shared DB) and re-index. Use this to receive contributions others have merged."
+).action(async () => {
+  const ctx = buildContext(stdoutLogger);
+  await runPull(ctx);
+});
+program.command("push").description("Contribute a caveat to the shared community DB via fork + PR (requires gh CLI).").argument("<id>", "entry id (from `caveat list`)").option("--dry-run", "show planned steps without making GitHub changes", false).action(async (id, opts) => {
+  const ctx = buildContext(stdoutLogger);
+  await runPush(ctx, { id, dryRun: opts.dryRun });
+});
 program.command("serve").description("Start the read-only web share portal").option("--port <n>", "port number", (v) => Number(v), 4242).action((opts) => {
   runServe({ port: opts.port });
 });