@ksm0709/context 0.0.29 → 0.0.31

package/dist/cli/index.js

@@ -2,9 +2,9 @@
 // @bun
 
 // src/cli/commands/update.ts
-import { resolve, join as join3 } from "path";
-import { existsSync as existsSync3 } from "fs";
-import { homedir } from "os";
+import { resolve as resolve3, join as join7 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { homedir as homedir3 } from "os";
 
 // src/lib/scaffold.ts
 import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
@@ -27,7 +27,7 @@ function resolveContextDir(projectDir) {
 // package.json
 var package_default = {
   name: "@ksm0709/context",
-  version: "0.0.29",
+  version: "0.0.31",
   author: {
     name: "TaehoKang",
     email: "ksm07091@gmail.com"
@@ -57,10 +57,10 @@ var package_default = {
     access: "public"
   },
   scripts: {
-    build: "bun build ./src/index.ts --outdir dist --target bun && bun build ./src/mcp.ts --outdir dist --target bun && bun build ./src/cli/index.ts --outdir dist/cli --target bun && bun build ./src/omx/index.ts --outdir dist/omx --target node --format esm --external jsonc-parser && mv dist/omx/index.js dist/omx/index.mjs",
+    build: "bun build ./src/index.ts --outdir dist --target bun && bun build ./src/mcp.ts --outdir dist --target bun && bun build ./src/cli/index.ts --outdir dist/cli --target bun && bun build ./src/omx/index.ts --outdir dist/omx --target node --format esm --external jsonc-parser && mv dist/omx/index.js dist/omx/index.mjs && bun build ./src/omc/session-start-hook.ts --outdir dist/omc --target bun && bun build ./src/omc/stop-hook.ts --outdir dist/omc --target bun",
     test: "vitest run",
     lint: "eslint src --ext .ts",
-    prepublishOnly: "bun build ./src/index.ts --outdir dist --target bun && bun build ./src/mcp.ts --outdir dist --target bun && bun build ./src/cli/index.ts --outdir dist/cli --target bun && bun build ./src/omx/index.ts --outdir dist/omx --target node --format esm --external jsonc-parser && mv dist/omx/index.js dist/omx/index.mjs"
+    prepublishOnly: "bun build ./src/index.ts --outdir dist --target bun && bun build ./src/mcp.ts --outdir dist --target bun && bun build ./src/cli/index.ts --outdir dist/cli --target bun && bun build ./src/omx/index.ts --outdir dist/omx --target node --format esm --external jsonc-parser && mv dist/omx/index.js dist/omx/index.mjs && bun build ./src/omc/session-start-hook.ts --outdir dist/omc --target bun && bun build ./src/omc/stop-hook.ts --outdir dist/omc --target bun"
   },
   files: [
     "dist"
@@ -69,7 +69,7 @@ var package_default = {
     "@opencode-ai/plugin": ">=1.0.0"
   },
   dependencies: {
-    "@ksm0709/context": "^0.0.28",
+    "@ksm0709/context": "^0.0.30",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "jsonc-parser": "^3.0.0"
   },
@@ -397,6 +397,29 @@ var TEMPLATE_FILES = {
   "index.md": DEFAULT_INDEX_TEMPLATE,
   "work-complete.txt": DEFAULT_WORK_COMPLETE_TEMPLATE
 };
+function scaffoldIfNeeded(projectDir) {
+  const contextDir = join2(projectDir, resolveContextDir(projectDir));
+  if (existsSync2(contextDir)) {
+    return false;
+  }
+  try {
+    const templatesDir = join2(contextDir, "templates");
+    mkdirSync(templatesDir, { recursive: true });
+    const guidesDir = join2(contextDir, "guides");
+    mkdirSync(guidesDir, { recursive: true });
+    writeFileSync(join2(contextDir, "config.jsonc"), DEFAULT_CONFIG, "utf-8");
+    for (const [filename, content] of Object.entries(TEMPLATE_FILES)) {
+      writeFileSync(join2(templatesDir, filename), content, "utf-8");
+    }
+    for (const [filename, content] of Object.entries(GUIDE_FILES)) {
+      writeFileSync(join2(guidesDir, filename), content, "utf-8");
+    }
+    writeVersion(contextDir, PLUGIN_VERSION);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function updateScaffold(projectDir) {
   const contextDir = join2(projectDir, resolveContextDir(projectDir));
   mkdirSync(join2(contextDir, "templates"), { recursive: true });
@@ -426,199 +449,63 @@ function writeVersion(contextDir, version) {
   writeFileSync(join2(contextDir, ".version"), version, "utf-8");
 }
 
-// src/cli/commands/update.ts
-var KNOWN_SUBCOMMANDS = ["all", "prompt", "plugin"];
-function runUpdate(args) {
-  const [subcommand, ...rest] = args;
-  switch (subcommand) {
-    case undefined:
-    case "all":
-      runUpdateAll(resolve(rest[0] ?? process.cwd()));
-      break;
-    case "prompt":
-      process.stdout.write(`Prompt update is no longer supported.
-`);
-      break;
-    case "plugin":
-      runUpdatePlugin(rest[0] ?? "latest");
-      break;
-    default:
-      if (!KNOWN_SUBCOMMANDS.includes(subcommand)) {
-        runUpdateAll(resolve(subcommand));
-      } else {
-        process.stderr.write(`Unknown update subcommand: ${subcommand}
-`);
-        process.exit(1);
-      }
-      break;
-  }
-}
-function runUpdateAll(projectDir) {
-  const updated = updateScaffold(projectDir);
-  if (updated.length === 0) {
-    process.stdout.write(`All scaffold files are already up to date.
-`);
-  } else {
-    process.stdout.write(`Updated ${updated.length} file(s):
-`);
-    for (const f of updated) {
-      process.stdout.write(`  - ${f}
-`);
-    }
-  }
-}
-function detectPackageManager() {
-  if (existsSync3("bun.lock") || existsSync3("bun.lockb"))
-    return "bun";
-  if (existsSync3("pnpm-lock.yaml"))
-    return "pnpm";
-  if (existsSync3("yarn.lock"))
-    return "yarn";
-  if (existsSync3("package-lock.json"))
-    return "npm";
-  return "bun";
-}
-function detectGlobalInstalls() {
-  const installs = [];
-  const bunGlobalBin = join3(homedir(), ".bun", "bin", "context");
-  if (existsSync3(bunGlobalBin)) {
-    installs.push({ pm: "bun", label: "bun global", installCmd: ["bun", "install", "-g"] });
-  }
-  const spawnSync = globalThis.Bun?.spawnSync;
-  if (spawnSync) {
-    const whichResult = spawnSync(["which", "context"]);
-    if (whichResult.exitCode === 0) {
-      const binPath = whichResult.stdout.toString().trim();
-      if (binPath && !binPath.includes(".bun") && !binPath.includes("node_modules")) {
-        installs.push({ pm: "npm", label: "npm global", installCmd: ["npm", "install", "-g"] });
-      }
-    }
-  }
-  return installs;
-}
-function runUpdatePlugin(version) {
-  const pkg = `@ksm0709/context@${version}`;
-  const spawnSync = globalThis.Bun?.spawnSync;
-  if (!spawnSync) {
-    process.stderr.write(`Bun runtime required for plugin updates.
-`);
-    process.exit(1);
-    return;
-  }
-  const globalInstalls = detectGlobalInstalls();
-  for (const { label, installCmd } of globalInstalls) {
-    process.stdout.write(`Updating ${label} ${pkg}...
-`);
-    const result = spawnSync([...installCmd, pkg]);
-    if (result.exitCode !== 0) {
-      process.stderr.write(`Failed to update ${label}: ${result.stderr.toString()}
-`);
-      process.exit(1);
-      return;
-    }
-    process.stdout.write(`Successfully updated ${label} ${pkg}.
-`);
-  }
-  const pm = detectPackageManager();
-  process.stdout.write(`Updating local ${pkg} using ${pm}...
-`);
-  const localResult = spawnSync([pm, "add", pkg]);
-  if (localResult.exitCode !== 0) {
-    process.stderr.write(`Failed to update local: ${localResult.stderr.toString()}
-`);
-    process.exit(1);
-    return;
-  }
-  process.stdout.write(`Successfully updated local ${pkg}.
-`);
-}
-
-// src/cli/commands/migrate.ts
-import { resolve as resolve2, join as join4 } from "path";
-import { existsSync as existsSync4, cpSync, rmSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-var LEGACY_CONTEXT_DIR = ".opencode/context";
-var NEW_CONTEXT_DIR = ".context";
-function runMigrate(args) {
-  const keepFlag = args.includes("--keep");
-  const pathArg = args.find((a) => !a.startsWith("--"));
-  const projectDir = resolve2(pathArg ?? process.cwd());
-  const legacyDir = join4(projectDir, LEGACY_CONTEXT_DIR);
-  const newDir = join4(projectDir, NEW_CONTEXT_DIR);
-  if (!existsSync4(legacyDir)) {
-    process.stdout.write(`Nothing to migrate.
-`);
-    return;
-  }
-  if (existsSync4(newDir)) {
-    process.stderr.write(`Target .context/ already exists. Aborting.
-`);
-    process.exit(1);
-    return;
-  }
-  cpSync(legacyDir, newDir, { recursive: true });
-  updateConfigPaths(newDir);
-  if (!keepFlag) {
-    rmSync(legacyDir, { recursive: true, force: true });
-  }
-  process.stdout.write(`Migrated .opencode/context/ \u2192 .context/
-`);
-}
-function updateConfigPaths(contextDir) {
-  const configPath = join4(contextDir, "config.jsonc");
-  if (!existsSync4(configPath))
-    return;
-  try {
-    const content = readFileSync2(configPath, "utf-8");
-    const updated = content.replaceAll(".opencode/context/", "");
-    if (updated !== content) {
-      writeFileSync2(configPath, updated, "utf-8");
-    }
-  } catch {}
-}
-
 // src/cli/commands/install.ts
-import { join as join6, resolve as resolve4, dirname as dirname2 } from "path";
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, copyFileSync } from "fs";
+import { join as join6, resolve as resolve2, dirname as dirname5 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, copyFileSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
+import { execSync } from "child_process";
 
 // src/omx/registry.ts
+import { join as join4, dirname as dirname2 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { homedir } from "os";
+
+// src/shared/mcp-path.ts
 import { fileURLToPath } from "url";
-import { dirname, join as join5, resolve as resolve3 } from "path";
-import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
-import { homedir as homedir2 } from "os";
+import { dirname, join as join3, resolve } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { createRequire } from "module";
 function resolveMcpPath() {
+  try {
+    const req = createRequire(import.meta.url);
+    const pkgJsonPath = req.resolve("@ksm0709/context/package.json");
+    const pkgRoot = dirname(pkgJsonPath);
+    const distMcp = join3(pkgRoot, "dist", "mcp.js");
+    if (existsSync3(distMcp))
+      return distMcp;
+  } catch {}
   const currentFile = fileURLToPath(import.meta.url);
   const currentDir = dirname(currentFile);
-  const distMcpPath = resolve3(currentDir, "..", "mcp.js");
-  if (existsSync5(distMcpPath)) {
+  const distMcpPath = resolve(currentDir, "..", "mcp.js");
+  if (existsSync3(distMcpPath))
     return distMcpPath;
-  }
-  const srcMcpPath = resolve3(currentDir, "..", "mcp.ts");
-  if (existsSync5(srcMcpPath)) {
+  const srcMcpPath = resolve(currentDir, "..", "mcp.ts");
+  if (existsSync3(srcMcpPath))
     return srcMcpPath;
-  }
   return distMcpPath;
 }
+
+// src/omx/registry.ts
 function getRegistryPaths() {
   return [
-    join5(homedir2(), ".omx", "mcp-registry.json"),
-    join5(homedir2(), ".omc", "mcp-registry.json")
+    join4(homedir(), ".omx", "mcp-registry.json"),
+    join4(homedir(), ".omc", "mcp-registry.json")
   ];
 }
 function ensureMcpRegistered(sdkLog) {
   const registryPaths = getRegistryPaths();
   let targetPath = registryPaths[0];
   for (const p of registryPaths) {
-    if (existsSync5(p)) {
+    if (existsSync4(p)) {
       targetPath = p;
       break;
     }
   }
   let registry = {};
-  if (existsSync5(targetPath)) {
+  if (existsSync4(targetPath)) {
     try {
-      const content = readFileSync3(targetPath, "utf-8");
+      const content = readFileSync2(targetPath, "utf-8");
       registry = JSON.parse(content);
     } catch (e) {
       if (sdkLog) {
@@ -644,8 +531,8 @@ function ensureMcpRegistered(sdkLog) {
   }
   if (changed) {
     try {
-      mkdirSync2(dirname(targetPath), { recursive: true });
-      writeFileSync3(targetPath, JSON.stringify(registry, null, 2), "utf-8");
+      mkdirSync2(dirname2(targetPath), { recursive: true });
+      writeFileSync2(targetPath, JSON.stringify(registry, null, 2), "utf-8");
       if (sdkLog) {
         sdkLog(`[INFO] Registered context_mcp in ${targetPath}`);
       }
@@ -660,86 +547,1802 @@ function ensureMcpRegistered(sdkLog) {
   return false;
 }
 
-// src/cli/commands/install.ts
-function resolveOmxSource() {
-  try {
-    const cliDir = dirname2(fileURLToPath2(import.meta.url));
-    const pkgRoot = resolve4(cliDir, "..", "..");
-    const source = join6(pkgRoot, "dist", "omx", "index.mjs");
-    if (existsSync6(source))
-      return source;
-  } catch {}
-  try {
-    const req = createRequire(import.meta.url);
-    return req.resolve("@ksm0709/context/omx");
-  } catch {
-    return null;
+// src/shared/agents-md.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3 } from "path";
+var START_MARKER = "<!-- context:start -->";
+var END_MARKER = "<!-- context:end -->";
+function renderMarkerBlock(content, trailingNewline) {
+  const block = `${START_MARKER}
+${content}
+${END_MARKER}`;
+  if (trailingNewline) {
+    return `${block}
+`;
   }
+  return block;
 }
-function installOmx(projectDir, sourcePath) {
-  if (!existsSync6(sourcePath)) {
-    process.stderr.write(`Could not find OMX plugin source file: ${sourcePath}
-`);
-    process.exit(1);
-    return;
+function appendMarkerBlock(existingContent, content) {
+  if (existingContent.length === 0) {
+    return renderMarkerBlock(content, true);
   }
-  const targetDir = join6(projectDir, ".omx", "hooks");
-  mkdirSync3(targetDir, { recursive: true });
-  copyFileSync(sourcePath, join6(targetDir, "context.mjs"));
-  process.stdout.write(`Installed context plugin to .omx/hooks/context.mjs
-`);
-  if (ensureMcpRegistered()) {
-    process.stdout.write(`Successfully registered context-mcp in ~/.omx/mcp-registry.json
-`);
+  const separator = existingContent.endsWith(`
+`) ? `
+` : `
+
+`;
+  return `${existingContent}${separator}${renderMarkerBlock(content, true)}`;
+}
+function replaceMarkerBlock(existingContent, content) {
+  const startIndex = existingContent.indexOf(START_MARKER);
+  const endIndex = existingContent.indexOf(END_MARKER, startIndex + START_MARKER.length);
+  if (startIndex === -1 || endIndex === -1 || endIndex < startIndex) {
+    return appendMarkerBlock(existingContent, content);
   }
+  const before = existingContent.slice(0, startIndex);
+  const after = existingContent.slice(endIndex + END_MARKER.length);
+  const replacement = renderMarkerBlock(content, false);
+  return `${before}${replacement}${after}`;
 }
-function runInstall(args) {
-  const [subcommand] = args;
-  switch (subcommand) {
-    case "omx": {
-      const source = resolveOmxSource();
-      if (!source) {
-        process.stderr.write(`Could not find OMX plugin source file (dist/omx/index.mjs).
-`);
-        process.exit(1);
-        return;
-      }
-      installOmx(process.cwd(), source);
-      break;
-    }
-    case undefined:
-      process.stderr.write(`Missing install target. Usage: context install omx
-`);
-      process.exit(1);
-      break;
-    default:
-      process.stderr.write(`Unknown install target: ${subcommand}
-`);
-      process.exit(1);
+function writeFileAtomically(filePath, content) {
+  const tempPath = `${filePath}.tmp`;
+  writeFileSync3(tempPath, content, "utf-8");
+  renameSync(tempPath, filePath);
+}
+function injectIntoAgentsMd(agentsMdPath, content) {
+  mkdirSync3(dirname3(agentsMdPath), { recursive: true });
+  if (!existsSync5(agentsMdPath)) {
+    writeFileAtomically(agentsMdPath, renderMarkerBlock(content, true));
+    return;
   }
+  const existingContent = readFileSync3(agentsMdPath, "utf-8");
+  const nextContent = existingContent.includes(START_MARKER) && existingContent.includes(END_MARKER) ? replaceMarkerBlock(existingContent, content) : appendMarkerBlock(existingContent, content);
+  writeFileAtomically(agentsMdPath, nextContent);
 }
 
-// src/cli/index.ts
-var PLUGIN_VERSION2 = package_default.version;
-function printHelp(out) {
-  const write = out ?? ((s) => process.stdout.write(s));
-  write(`Context Plugin CLI v${PLUGIN_VERSION2}
-
-`);
-  write(`Usage: context <command> [options]
+// src/shared/knowledge-context.ts
+var STATIC_KNOWLEDGE_CONTEXT = `## Knowledge Context
+
+\uC774 \uD504\uB85C\uC81D\uD2B8\uB294 **\uC81C\uD154\uCE74\uC2A4\uD150(Zettelkasten)** \uBC29\uC2DD\uC73C\uB85C \uC9C0\uC2DD\uC744 \uAD00\uB9AC\uD569\uB2C8\uB2E4.
+\uC138\uC158 \uAC04 \uCEE8\uD14D\uC2A4\uD2B8\uB97C \uBCF4\uC874\uD558\uC5EC, \uC774\uC804 \uC138\uC158\uC758 \uACB0\uC815/\uD328\uD134/\uC2E4\uC218\uAC00 \uB2E4\uC74C \uC138\uC158\uC5D0\uC11C \uC7AC\uD65C\uC6A9\uB429\uB2C8\uB2E4.
+
+### \uC81C\uD154\uCE74\uC2A4\uD150 \uD575\uC2EC \uC6D0\uCE59
+1. **\uC6D0\uC790\uC131** -- \uD558\uB098\uC758 \uB178\uD2B8 = \uD558\uB098\uC758 \uC8FC\uC81C. \uC5EC\uB7EC \uC8FC\uC81C\uB97C \uC11E\uC9C0 \uB9C8\uC138\uC694.
+2. **\uC5F0\uACB0** -- \uBAA8\uB4E0 \uB178\uD2B8\uB294 [[wikilink]]\uB85C \uAD00\uB828 \uB178\uD2B8\uC5D0 \uC5F0\uACB0. \uACE0\uB9BD\uB41C \uB178\uD2B8\uB294 \uBC1C\uACAC\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.
+3. **\uC790\uAE30 \uC5B8\uC5B4** -- \uBCF5\uC0AC-\uBD99\uC5EC\uB123\uAE30\uAC00 \uC544\uB2CC, \uD575\uC2EC\uC744 \uC774\uD574\uD558\uACE0 \uAC04\uACB0\uD558\uAC8C \uC11C\uC220\uD558\uC138\uC694.
+
+### MCP Tools
+- **\uC9C0\uC2DD \uAD00\uB9AC**: \`context_mcp_search_knowledge\`, \`context_mcp_read_knowledge\`, \`context_mcp_create_knowledge_note\`, \`context_mcp_update_knowledge_note\`
+- **\uB370\uC77C\uB9AC \uB178\uD2B8**: \`context_mcp_read_daily_note\`, \`context_mcp_append_daily_note\`
+- **\uC791\uC5C5 \uC644\uB8CC**: \`context_mcp_submit_turn_complete\` (\uC791\uC5C5 \uC885\uB8CC \uC2DC \uD544\uC218 \uD638\uCD9C)
+
+### \uC791\uC5C5 \uC804 \uD544\uC218
+- **\uB370\uC77C\uB9AC \uB178\uD2B8 \uD655\uC778**: \uAC00\uC7A5 \uCD5C\uADFC\uC758 \uB370\uC77C\uB9AC \uB178\uD2B8\uB97C \uC77D\uACE0 \uC774\uC804 \uC138\uC158\uC758 \uCEE8\uD14D\uC2A4\uD2B8\uC640 \uBBF8\uD574\uACB0 \uC774\uC288\uB97C \uD30C\uC545\uD558\uC138\uC694.
+- **\uC791\uC5C5 \uC758\uB3C4 \uC120\uC5B8**: \uC791\uC5C5 \uC2DC\uC791 \uC804, \uD604\uC7AC \uC138\uC158\uC758 \uBAA9\uD45C\uC640 \uC791\uC5C5 \uC758\uB3C4\uB97C \uBA85\uD655\uD788 \uD30C\uC545\uD558\uACE0 \uC120\uC5B8\uD558\uC138\uC694.
+- **\uC9C0\uC2DD \uAC80\uC0C9**: \uC791\uC5C5\uACFC \uAD00\uB828\uB41C \uBB38\uC11C\uB97C **\uC9C1\uC811 \uBA3C\uC800** \uAC80\uC0C9\uD558\uACE0 \uC77D\uC73C\uC138\uC694.
+- \uC9C0\uC2DD \uD30C\uC77C\uC5D0 \uAE30\uB85D\uB41C \uC544\uD0A4\uD14D\uCC98 \uACB0\uC815, \uD328\uD134, \uC81C\uC57D\uC0AC\uD56D\uC744 \uBC18\uB4DC\uC2DC \uB530\uB974\uC138\uC694.
+
+### \uAC1C\uBC1C \uC6D0\uCE59
+- **TDD** (Test-Driven Development): \uD14C\uC2A4\uD2B8\uB97C \uBA3C\uC800 \uC791\uC131\uD558\uACE0(RED), \uAD6C\uD604\uD558\uC5EC \uD1B5\uACFC\uC2DC\uD0A8 \uB4A4(GREEN), \uB9AC\uD329\uD1A0\uB9C1\uD558\uC138\uC694.
+- **DDD** (Domain-Driven Design): \uB3C4\uBA54\uC778 \uAC1C\uB150\uC744 \uCF54\uB4DC \uAD6C\uC870\uC5D0 \uBC18\uC601\uD558\uC138\uC694.
+- **\uD14C\uC2A4\uD2B8 \uCEE4\uBC84\uB9AC\uC9C0**: \uC0C8\uB85C \uC791\uC131\uD558\uAC70\uB098 \uBCC0\uACBD\uD55C \uCF54\uB4DC\uB294 \uD14C\uC2A4\uD2B8 \uCEE4\uBC84\uB9AC\uC9C0 80% \uC774\uC0C1\uC744 \uBAA9\uD45C\uB85C \uD558\uC138\uC694.
+
+### \uC6B0\uC120\uC21C\uC704
+- AGENTS.md\uC758 \uC9C0\uC2DC\uC0AC\uD56D\uC774 \uD56D\uC0C1 \uCD5C\uC6B0\uC120
+- \uC9C0\uC2DD \uB178\uD2B8\uC758 \uACB0\uC815\uC0AC\uD56D > \uC77C\uBC18\uC801 \uAD00\uD589
+- \uC9C0\uC2DD \uB178\uD2B8\uC5D0 \uC5C6\uB294 \uC0C8\uB85C\uC6B4 \uACB0\uC815\uC774\uB098 \uBC18\uBCF5 \uAC00\uCE58\uAC00 \uC788\uB294 \uBC1C\uACAC\uC740 \uC791\uC5C5 \uBA54\uBAA8\uB098 \uC9C0\uC2DD \uB178\uD2B8 \uD6C4\uBCF4\uB85C \uAE30\uB85D\uD558\uC138\uC694.
+
+### \uC791\uC5C5 \uC644\uB8CC \uD504\uB85C\uD1A0\uCF5C
+- **\uD544\uC218**: \uBAA8\uB4E0 \uC791\uC5C5\uC774 \uC644\uB8CC\uB418\uBA74 \uBC18\uB4DC\uC2DC \`context-mcp\` MCP \uC11C\uBC84\uC758 \`submit_turn_complete\` \uB3C4\uAD6C\uB97C \uD638\uCD9C\uD558\uC138\uC694.
+- \uC774 \uD638\uCD9C \uC5C6\uC774 \uC138\uC158\uC744 \uC885\uB8CC\uD558\uBA74 \uC791\uC5C5 \uAE30\uB85D\uC774 \uBCF4\uC874\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.
+- \uD544\uC694\uD55C \uC778\uC790: daily_note_update_proof, knowledge_note_proof, quality_check_output, checkpoint_commit_hashes, scope_review_notes`;
+
+// src/shared/claude-settings.ts
+import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync4, renameSync as renameSync2, mkdirSync as mkdirSync4 } from "fs";
+import { dirname as dirname4, join as join5 } from "path";
+import { homedir as homedir2 } from "os";
 
-`);
-  write(`Commands:
-`);
-  write(`  update [all] [path]        Force-update all scaffold files
-`);
-  write(`  update prompt [path]       Force-update prompt files only
-`);
-  write(`  update plugin [version]    Update @ksm0709/context package
-`);
-  write(`  migrate [path] [--keep]    Migrate .opencode/context/ \u2192 .context/
-`);
-  write(`  install omx                Install OMX hook plugin to .omx/hooks/
+// node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += `
+`;
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "\t";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += `
+`;
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + " ".repeat(index);
+    })
+  },
+  "\t": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + "\t".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "\t".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + "\t".repeat(index);
+    })
+  }
+};
+var supportedEols = [`
+`, "\r", `\r
+`];
+
+// node_modules/jsonc-parser/lib/esm/impl/format.js
+function format(documentText, range, options) {
+  let initialIndentLevel;
+  let formatText;
+  let formatTextStart;
+  let rangeStart;
+  let rangeEnd;
+  if (range) {
+    rangeStart = range.offset;
+    rangeEnd = rangeStart + range.length;
+    formatTextStart = rangeStart;
+    while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
+      formatTextStart--;
+    }
+    let endOffset = rangeEnd;
+    while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
+      endOffset++;
+    }
+    formatText = documentText.substring(formatTextStart, endOffset);
+    initialIndentLevel = computeIndentLevel(formatText, options);
+  } else {
+    formatText = documentText;
+    initialIndentLevel = 0;
+    formatTextStart = 0;
+    rangeStart = 0;
+    rangeEnd = documentText.length;
+  }
+  const eol = getEOL(options, documentText);
+  const eolFastPathSupported = supportedEols.includes(eol);
+  let numberLineBreaks = 0;
+  let indentLevel = 0;
+  let indentValue;
+  if (options.insertSpaces) {
+    indentValue = cachedSpaces[options.tabSize || 4] ?? repeat(cachedSpaces[1], options.tabSize || 4);
+  } else {
+    indentValue = "\t";
+  }
+  const indentType = indentValue === "\t" ? "\t" : " ";
+  let scanner = createScanner(formatText, false);
+  let hasError = false;
+  function newLinesAndIndent() {
+    if (numberLineBreaks > 1) {
+      return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    const amountOfSpaces = indentValue.length * (initialIndentLevel + indentLevel);
+    if (!eolFastPathSupported || amountOfSpaces > cachedBreakLinesWithSpaces[indentType][eol].length) {
+      return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    if (amountOfSpaces <= 0) {
+      return eol;
+    }
+    return cachedBreakLinesWithSpaces[indentType][eol][amountOfSpaces];
+  }
+  function scanNext() {
+    let token = scanner.scan();
+    numberLineBreaks = 0;
+    while (token === 15 || token === 14) {
+      if (token === 14 && options.keepLines) {
+        numberLineBreaks += 1;
+      } else if (token === 14) {
+        numberLineBreaks = 1;
+      }
+      token = scanner.scan();
+    }
+    hasError = token === 16 || scanner.getTokenError() !== 0;
+    return token;
+  }
+  const editOperations = [];
+  function addEdit(text, startOffset, endOffset) {
+    if (!hasError && (!range || startOffset < rangeEnd && endOffset > rangeStart) && documentText.substring(startOffset, endOffset) !== text) {
+      editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
+    }
+  }
+  let firstToken = scanNext();
+  if (options.keepLines && numberLineBreaks > 0) {
+    addEdit(repeat(eol, numberLineBreaks), 0, 0);
+  }
+  if (firstToken !== 17) {
+    let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+    let initialIndent = indentValue.length * initialIndentLevel < 20 && options.insertSpaces ? cachedSpaces[indentValue.length * initialIndentLevel] : repeat(indentValue, initialIndentLevel);
+    addEdit(initialIndent, formatTextStart, firstTokenStart);
+  }
+  while (firstToken !== 17) {
+    let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+    let secondToken = scanNext();
+    let replaceContent = "";
+    let needsLineBreak = false;
+    while (numberLineBreaks === 0 && (secondToken === 12 || secondToken === 13)) {
+      let commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+      addEdit(cachedSpaces[1], firstTokenEnd, commentTokenStart);
+      firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+      needsLineBreak = secondToken === 12;
+      replaceContent = needsLineBreak ? newLinesAndIndent() : "";
+      secondToken = scanNext();
+    }
+    if (secondToken === 2) {
+      if (firstToken !== 1) {
+        indentLevel--;
+      }
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 1) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else if (secondToken === 4) {
+      if (firstToken !== 3) {
+        indentLevel--;
+      }
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 3) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else {
+      switch (firstToken) {
+        case 3:
+        case 1:
+          indentLevel++;
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 5:
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 12:
+          replaceContent = newLinesAndIndent();
+          break;
+        case 13:
+          if (numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 6:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 10:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (secondToken === 6 && !needsLineBreak) {
+            replaceContent = "";
+          }
+          break;
+        case 7:
+        case 8:
+        case 9:
+        case 11:
+        case 2:
+        case 4:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            if ((secondToken === 12 || secondToken === 13) && !needsLineBreak) {
+              replaceContent = cachedSpaces[1];
+            } else if (secondToken !== 5 && secondToken !== 17) {
+              hasError = true;
+            }
+          }
+          break;
+        case 16:
+          hasError = true;
+          break;
+      }
+      if (numberLineBreaks > 0 && (secondToken === 12 || secondToken === 13)) {
+        replaceContent = newLinesAndIndent();
+      }
+    }
+    if (secondToken === 17) {
+      if (options.keepLines && numberLineBreaks > 0) {
+        replaceContent = newLinesAndIndent();
+      } else {
+        replaceContent = options.insertFinalNewline ? eol : "";
+      }
+    }
+    const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
+    addEdit(replaceContent, firstTokenEnd, secondTokenStart);
+    firstToken = secondToken;
+  }
+  return editOperations;
+}
+function repeat(s, count) {
+  let result = "";
+  for (let i = 0;i < count; i++) {
+    result += s;
+  }
+  return result;
+}
+function computeIndentLevel(content, options) {
+  let i = 0;
+  let nChars = 0;
+  const tabSize = options.tabSize || 4;
+  while (i < content.length) {
+    let ch = content.charAt(i);
+    if (ch === cachedSpaces[1]) {
+      nChars++;
+    } else if (ch === "\t") {
+      nChars += tabSize;
+    } else {
+      break;
+    }
+    i++;
+  }
+  return Math.floor(nChars / tabSize);
+}
+function getEOL(options, text) {
+  for (let i = 0;i < text.length; i++) {
+    const ch = text.charAt(i);
+    if (ch === "\r") {
+      if (i + 1 < text.length && text.charAt(i + 1) === `
+`) {
+        return `\r
+`;
+      }
+      return "\r";
+    } else if (ch === `
+`) {
+      return `
+`;
+    }
+  }
+  return options && options.eol || `
+`;
+}
+function isEOL(text, offset) {
+  return `\r
+`.indexOf(text.charAt(offset)) !== -1;
+}
+
+// node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
+function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentParent = { type: "array", offset: -1, length: -1, children: [], parent: undefined };
+  function ensurePropertyComplete(endOffset) {
+    if (currentParent.type === "property") {
+      currentParent.length = endOffset - currentParent.offset;
+      currentParent = currentParent.parent;
+    }
+  }
+  function onValue(valueNode) {
+    currentParent.children.push(valueNode);
+    return valueNode;
+  }
+  const visitor = {
+    onObjectBegin: (offset) => {
+      currentParent = onValue({ type: "object", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onObjectProperty: (name, offset, length) => {
+      currentParent = onValue({ type: "property", offset, length: -1, parent: currentParent, children: [] });
+      currentParent.children.push({ type: "string", value: name, offset, length, parent: currentParent });
+    },
+    onObjectEnd: (offset, length) => {
+      ensurePropertyComplete(offset + length);
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onArrayBegin: (offset, length) => {
+      currentParent = onValue({ type: "array", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onArrayEnd: (offset, length) => {
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onLiteralValue: (value, offset, length) => {
+      onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
+      ensurePropertyComplete(offset + length);
+    },
+    onSeparator: (sep, offset, length) => {
+      if (currentParent.type === "property") {
+        if (sep === ":") {
+          currentParent.colonOffset = offset;
+        } else if (sep === ",") {
+          ensurePropertyComplete(offset);
+        }
+      }
+    },
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  const result = currentParent.children[0];
+  if (result) {
+    delete result.parent;
+  }
+  return result;
+}
+function findNodeAtLocation(root, path) {
+  if (!root) {
+    return;
+  }
+  let node = root;
+  for (let segment of path) {
+    if (typeof segment === "string") {
+      if (node.type !== "object" || !Array.isArray(node.children)) {
+        return;
+      }
+      let found = false;
+      for (const propertyNode of node.children) {
+        if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+          node = propertyNode.children[1];
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return;
+      }
+    } else {
+      const index = segment;
+      if (node.type !== "array" || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
+        return;
+      }
+      node = node.children[index];
+    }
+  }
+  return node;
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(14);
+          break;
+        case 5:
+          handleError(15);
+          break;
+        case 3:
+          handleError(13);
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(11);
+          }
+          break;
+        case 2:
+          handleError(12);
+          break;
+        case 6:
+          handleError(16);
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(10);
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(1);
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(2);
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [2, 5]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [2, 5]);
+      }
+    } else {
+      handleError(5, [], [2, 5]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [2, 5]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [2], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [4, 5]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [4], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+function getNodeType(value) {
+  switch (typeof value) {
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "object": {
+      if (!value) {
+        return "null";
+      } else if (Array.isArray(value)) {
+        return "array";
+      }
+      return "object";
+    }
+    default:
+      return "null";
+  }
+}
+
+// node_modules/jsonc-parser/lib/esm/impl/edit.js
+function setProperty(text, originalPath, value, options) {
+  const path = originalPath.slice();
+  const errors = [];
+  const root = parseTree(text, errors);
+  let parent = undefined;
+  let lastSegment = undefined;
+  while (path.length > 0) {
+    lastSegment = path.pop();
+    parent = findNodeAtLocation(root, path);
+    if (parent === undefined && value !== undefined) {
+      if (typeof lastSegment === "string") {
+        value = { [lastSegment]: value };
+      } else {
+        value = [value];
+      }
+    } else {
+      break;
+    }
+  }
+  if (!parent) {
+    if (value === undefined) {
+      throw new Error("Can not delete in empty document");
+    }
+    return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, options);
+  } else if (parent.type === "object" && typeof lastSegment === "string" && Array.isArray(parent.children)) {
+    const existing = findNodeAtLocation(parent, [lastSegment]);
+    if (existing !== undefined) {
+      if (value === undefined) {
+        if (!existing.parent) {
+          throw new Error("Malformed AST");
+        }
+        const propertyIndex = parent.children.indexOf(existing.parent);
+        let removeBegin;
+        let removeEnd = existing.parent.offset + existing.parent.length;
+        if (propertyIndex > 0) {
+          let previous = parent.children[propertyIndex - 1];
+          removeBegin = previous.offset + previous.length;
+        } else {
+          removeBegin = parent.offset + 1;
+          if (parent.children.length > 1) {
+            let next = parent.children[1];
+            removeEnd = next.offset;
+          }
+        }
+        return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: "" }, options);
+      } else {
+        return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, options);
+      }
+    } else {
+      if (value === undefined) {
+        return [];
+      }
+      const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+      const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map((p) => p.children[0].value)) : parent.children.length;
+      let edit;
+      if (index > 0) {
+        let previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      } else if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty + "," };
+      }
+      return withFormatting(text, edit, options);
+    }
+  } else if (parent.type === "array" && typeof lastSegment === "number" && Array.isArray(parent.children)) {
+    const insertIndex = lastSegment;
+    if (insertIndex === -1) {
+      const newProperty = `${JSON.stringify(value)}`;
+      let edit;
+      if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        const previous = parent.children[parent.children.length - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value === undefined && parent.children.length >= 0) {
+      const removalIndex = lastSegment;
+      const toRemove = parent.children[removalIndex];
+      let edit;
+      if (parent.children.length === 1) {
+        edit = { offset: parent.offset + 1, length: parent.length - 2, content: "" };
+      } else if (parent.children.length - 1 === removalIndex) {
+        let previous = parent.children[removalIndex - 1];
+        let offset = previous.offset + previous.length;
+        let parentEndOffset = parent.offset + parent.length;
+        edit = { offset, length: parentEndOffset - 2 - offset, content: "" };
+      } else {
+        edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: "" };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value !== undefined) {
+      let edit;
+      const newProperty = `${JSON.stringify(value)}`;
+      if (!options.isArrayInsertion && parent.children.length > lastSegment) {
+        const toModify = parent.children[lastSegment];
+        edit = { offset: toModify.offset, length: toModify.length, content: newProperty };
+      } else if (parent.children.length === 0 || lastSegment === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + "," };
+      } else {
+        const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
+        const previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else {
+      throw new Error(`Can not ${value === undefined ? "remove" : options.isArrayInsertion ? "insert" : "modify"} Array index ${insertIndex} as length is not sufficient`);
+    }
+  } else {
+    throw new Error(`Can not add ${typeof lastSegment !== "number" ? "index" : "property"} to parent of type ${parent.type}`);
+  }
+}
+function withFormatting(text, edit, options) {
+  if (!options.formattingOptions) {
+    return [edit];
+  }
+  let newText = applyEdit(text, edit);
+  let begin = edit.offset;
+  let end = edit.offset + edit.content.length;
+  if (edit.length === 0 || edit.content.length === 0) {
+    while (begin > 0 && !isEOL(newText, begin - 1)) {
+      begin--;
+    }
+    while (end < newText.length && !isEOL(newText, end)) {
+      end++;
+    }
+  }
+  const edits = format(newText, { offset: begin, length: end - begin }, { ...options.formattingOptions, keepLines: false });
+  for (let i = edits.length - 1;i >= 0; i--) {
+    const edit2 = edits[i];
+    newText = applyEdit(newText, edit2);
+    begin = Math.min(begin, edit2.offset);
+    end = Math.max(end, edit2.offset + edit2.length);
+    end += edit2.content.length - edit2.length;
+  }
+  const editLength = text.length - (newText.length - end) - begin;
+  return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
+}
+function applyEdit(text, edit) {
+  return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
+}
+
+// node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+function modify(text, path, value, options) {
+  return setProperty(text, path, value, options);
+}
+function applyEdits(text, edits) {
+  let sortedEdits = edits.slice(0).sort((a, b) => {
+    const diff = a.offset - b.offset;
+    if (diff === 0) {
+      return a.length - b.length;
+    }
+    return diff;
+  });
+  let lastModifiedOffset = text.length;
+  for (let i = sortedEdits.length - 1;i >= 0; i--) {
+    let e = sortedEdits[i];
+    if (e.offset + e.length <= lastModifiedOffset) {
+      text = applyEdit(text, e);
+    } else {
+      throw new Error("Overlapping edit");
+    }
+    lastModifiedOffset = e.offset;
+  }
+  return text;
+}
+
+// src/shared/claude-settings.ts
+var settingsPath = join5(homedir2(), ".claude", "settings.json");
+function readClaudeSettings() {
+  if (!existsSync6(settingsPath)) {
+    return {};
+  }
+  const content = readFileSync4(settingsPath, "utf8");
+  return parse2(content) ?? {};
+}
+function writeClaudeSettings(settings) {
+  const dir = dirname4(settingsPath);
+  if (!existsSync6(dir)) {
+    mkdirSync4(dir, { recursive: true });
+  }
+  let content;
+  if (existsSync6(settingsPath)) {
+    content = readFileSync4(settingsPath, "utf8");
+    for (const [key, value] of Object.entries(settings)) {
+      const edits = modify(content, [key], value, {});
+      content = applyEdits(content, edits);
+    }
+    const existing = parse2(content) ?? {};
+    for (const key of Object.keys(existing)) {
+      if (!(key in settings)) {
+        const edits = modify(content, [key], undefined, {});
+        content = applyEdits(content, edits);
+      }
+    }
+  } else {
+    content = JSON.stringify(settings, null, 2);
+  }
+  const tmp = settingsPath + ".tmp";
+  writeFileSync4(tmp, content, "utf8");
+  renameSync2(tmp, settingsPath);
+}
+function registerMcpServer(name, entry) {
+  const settings = readClaudeSettings();
+  if (!settings.mcpServers) {
+    settings.mcpServers = {};
+  }
+  settings.mcpServers[name] = entry;
+  writeClaudeSettings(settings);
+}
+function removeMcpServer(name) {
+  const settings = readClaudeSettings();
+  if (settings.mcpServers) {
+    delete settings.mcpServers[name];
+    writeClaudeSettings(settings);
+  }
+}
+function registerHook(event, rule) {
+  const settings = readClaudeSettings();
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  if (!settings.hooks[event]) {
+    settings.hooks[event] = [];
+  }
+  const rules = settings.hooks[event];
+  for (const hookCmd of rule.hooks) {
+    let replaced = false;
+    for (let i = 0;i < rules.length; i++) {
+      const existingIdx = rules[i].hooks.findIndex((h) => h.command === hookCmd.command);
+      if (existingIdx !== -1) {
+        rules[i] = rule;
+        replaced = true;
+        break;
+      }
+    }
+    if (!replaced) {
+      rules.push(rule);
+      break;
+    }
+  }
+  writeClaudeSettings(settings);
+}
+
+// src/cli/commands/install.ts
+function resolveOmxSource() {
+  try {
+    const cliDir = dirname5(fileURLToPath2(import.meta.url));
+    const pkgRoot = resolve2(cliDir, "..", "..");
+    const source = join6(pkgRoot, "dist", "omx", "index.mjs");
+    if (existsSync7(source))
+      return source;
+  } catch {}
+  try {
+    const req = createRequire2(import.meta.url);
+    return req.resolve("@ksm0709/context/omx");
+  } catch {
+    return null;
+  }
+}
+function installOmx(projectDir, sourcePath) {
+  if (!existsSync7(sourcePath)) {
+    process.stderr.write(`Could not find OMX plugin source file: ${sourcePath}
+`);
+    process.exit(1);
+    return;
+  }
+  const targetDir = join6(projectDir, ".omx", "hooks");
+  mkdirSync5(targetDir, { recursive: true });
+  copyFileSync(sourcePath, join6(targetDir, "context.mjs"));
+  process.stdout.write(`Installed context plugin to .omx/hooks/context.mjs
+`);
+  if (ensureMcpRegistered()) {
+    process.stdout.write(`Successfully registered context-mcp in ~/.omx/mcp-registry.json
+`);
+  }
+}
+function installOmc(projectDir) {
+  scaffoldIfNeeded(projectDir);
+  injectIntoAgentsMd(join6(projectDir, "AGENTS.md"), STATIC_KNOWLEDGE_CONTEXT);
+  let bunPath = "bun";
+  try {
+    bunPath = execSync("which bun", { encoding: "utf-8" }).trim();
+  } catch {}
+  const mcpPath = resolveMcpPath();
+  const hookBasePath = join6(dirname5(mcpPath), "omc") + "/";
+  removeMcpServer("context_mcp");
+  registerMcpServer("context-mcp", { command: bunPath, args: [mcpPath], enabled: true });
+  registerHook("SessionStart", {
+    matcher: "startup",
+    hooks: [
+      {
+        type: "command",
+        command: `${bunPath} ${hookBasePath}session-start-hook.js`,
+        timeout: 15,
+        statusMessage: "Initializing context plugin..."
+      }
+    ]
+  });
+  registerHook("Stop", {
+    hooks: [
+      {
+        type: "command",
+        command: `${bunPath} ${hookBasePath}stop-hook.js`,
+        timeout: 10,
+        statusMessage: "Checking turn completion..."
+      }
+    ]
+  });
+  process.stdout.write(`Successfully installed context (omc) plugin.
+`);
+}
+function runInstall(args) {
+  const [subcommand] = args;
+  switch (subcommand) {
+    case "omx": {
+      const source = resolveOmxSource();
+      if (!source) {
+        process.stderr.write(`Could not find OMX plugin source file (dist/omx/index.mjs).
+`);
+        process.exit(1);
+        return;
+      }
+      installOmx(process.cwd(), source);
+      break;
+    }
+    case "omc":
+    case "claude":
+      installOmc(process.cwd());
+      break;
+    case undefined:
+      process.stderr.write(`Missing install target. Usage: context install <omx|omc>
+`);
+      process.exit(1);
+      break;
+    default:
+      process.stderr.write(`Unknown install target: ${subcommand}
+`);
+      process.exit(1);
+  }
+}
+
+// src/cli/commands/update.ts
+var KNOWN_SUBCOMMANDS = ["all", "prompt", "plugin"];
+function runUpdate(args) {
+  const [subcommand, ...rest] = args;
+  switch (subcommand) {
+    case undefined:
+    case "all":
+      runUpdateAll(resolve3(rest[0] ?? process.cwd()));
+      break;
+    case "prompt":
+      process.stdout.write(`Prompt update is no longer supported.
+`);
+      break;
+    case "plugin":
+      runUpdatePlugin(rest[0] ?? "latest");
+      break;
+    default:
+      if (!KNOWN_SUBCOMMANDS.includes(subcommand)) {
+        runUpdateAll(resolve3(subcommand));
+      } else {
+        process.stderr.write(`Unknown update subcommand: ${subcommand}
+`);
+        process.exit(1);
+      }
+      break;
+  }
+}
+function isOmxInstalled(projectDir) {
+  return existsSync8(join7(projectDir, ".omx", "hooks", "context.mjs"));
+}
+function isOmcInstalled() {
+  try {
+    const settings = readClaudeSettings();
+    return settings.mcpServers != null && "context-mcp" in settings.mcpServers;
+  } catch {
+    return false;
+  }
+}
+function runUpdateAll(projectDir) {
+  const updated = updateScaffold(projectDir);
+  if (updated.length === 0) {
+    process.stdout.write(`All scaffold files are already up to date.
+`);
+  } else {
+    process.stdout.write(`Updated ${updated.length} file(s):
+`);
+    for (const f of updated) {
+      process.stdout.write(`  - ${f}
+`);
+    }
+  }
+  if (isOmcInstalled()) {
+    process.stdout.write(`
+Re-installing omc hooks and settings...
+`);
+    installOmc(projectDir);
+  }
+  if (isOmxInstalled(projectDir)) {
+    const source = resolveOmxSource();
+    if (source) {
+      process.stdout.write(`
+Re-installing omx plugin...
+`);
+      installOmx(projectDir, source);
+    } else {
+      process.stderr.write(`
+Warning: could not resolve omx source; skipping omx reinstall.
+`);
+    }
+  }
+}
+function detectPackageManager() {
+  if (existsSync8("bun.lock") || existsSync8("bun.lockb"))
+    return "bun";
+  if (existsSync8("pnpm-lock.yaml"))
+    return "pnpm";
+  if (existsSync8("yarn.lock"))
+    return "yarn";
+  if (existsSync8("package-lock.json"))
+    return "npm";
+  return "bun";
+}
+function detectGlobalInstalls() {
+  const installs = [];
+  const bunGlobalBin = join7(homedir3(), ".bun", "bin", "context");
+  if (existsSync8(bunGlobalBin)) {
+    installs.push({ pm: "bun", label: "bun global", installCmd: ["bun", "install", "-g"] });
+  }
+  const spawnSync = globalThis.Bun?.spawnSync;
+  if (spawnSync) {
+    const whichResult = spawnSync(["which", "context"]);
+    if (whichResult.exitCode === 0) {
+      const binPath = whichResult.stdout.toString().trim();
+      if (binPath && !binPath.includes(".bun") && !binPath.includes("node_modules")) {
+        installs.push({ pm: "npm", label: "npm global", installCmd: ["npm", "install", "-g"] });
+      }
+    }
+  }
+  return installs;
+}
+function runUpdatePlugin(version) {
+  const pkg = `@ksm0709/context@${version}`;
+  const spawnSync = globalThis.Bun?.spawnSync;
+  if (!spawnSync) {
+    process.stderr.write(`Bun runtime required for plugin updates.
+`);
+    process.exit(1);
+    return;
+  }
+  const globalInstalls = detectGlobalInstalls();
+  for (const { label, installCmd } of globalInstalls) {
+    process.stdout.write(`Updating ${label} ${pkg}...
+`);
+    const result = spawnSync([...installCmd, pkg]);
+    if (result.exitCode !== 0) {
+      process.stderr.write(`Failed to update ${label}: ${result.stderr.toString()}
+`);
+      process.exit(1);
+      return;
+    }
+    process.stdout.write(`Successfully updated ${label} ${pkg}.
+`);
+  }
+  const pm = detectPackageManager();
+  process.stdout.write(`Updating local ${pkg} using ${pm}...
+`);
+  const localResult = spawnSync([pm, "add", pkg]);
+  if (localResult.exitCode !== 0) {
+    process.stderr.write(`Failed to update local: ${localResult.stderr.toString()}
+`);
+    process.exit(1);
+    return;
+  }
+  process.stdout.write(`Successfully updated local ${pkg}.
+`);
+}
+
+// src/cli/commands/migrate.ts
+import { resolve as resolve4, join as join8 } from "path";
+import { existsSync as existsSync9, cpSync, rmSync, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+var LEGACY_CONTEXT_DIR = ".opencode/context";
+var NEW_CONTEXT_DIR = ".context";
+function runMigrate(args) {
+  const keepFlag = args.includes("--keep");
+  const pathArg = args.find((a) => !a.startsWith("--"));
+  const projectDir = resolve4(pathArg ?? process.cwd());
+  const legacyDir = join8(projectDir, LEGACY_CONTEXT_DIR);
+  const newDir = join8(projectDir, NEW_CONTEXT_DIR);
+  if (!existsSync9(legacyDir)) {
+    process.stdout.write(`Nothing to migrate.
+`);
+    return;
+  }
+  if (existsSync9(newDir)) {
+    process.stderr.write(`Target .context/ already exists. Aborting.
+`);
+    process.exit(1);
+    return;
+  }
+  cpSync(legacyDir, newDir, { recursive: true });
+  updateConfigPaths(newDir);
+  if (!keepFlag) {
+    rmSync(legacyDir, { recursive: true, force: true });
+  }
+  process.stdout.write(`Migrated .opencode/context/ \u2192 .context/
+`);
+}
+function updateConfigPaths(contextDir) {
+  const configPath = join8(contextDir, "config.jsonc");
+  if (!existsSync9(configPath))
+    return;
+  try {
+    const content = readFileSync5(configPath, "utf-8");
+    const updated = content.replaceAll(".opencode/context/", "");
+    if (updated !== content) {
+      writeFileSync5(configPath, updated, "utf-8");
+    }
+  } catch {}
+}
+
+// src/cli/index.ts
+var PLUGIN_VERSION2 = package_default.version;
+function printHelp(out) {
+  const write = out ?? ((s) => process.stdout.write(s));
+  write(`Context Plugin CLI v${PLUGIN_VERSION2}
+
+`);
+  write(`Usage: context <command> [options]
+
+`);
+  write(`Commands:
+`);
+  write(`  update [all] [path]        Force-update scaffold + reinstall omc/omx
+`);
+  write(`  update prompt [path]       Force-update prompt files only
+`);
+  write(`  update plugin [version]    Update @ksm0709/context package
+`);
+  write(`  migrate [path] [--keep]    Migrate .opencode/context/ \u2192 .context/
+`);
+  write(`  install omx                Install OMX hook plugin to .omx/hooks/
+`);
+  write(`  install omc                Install OMC hooks/MCP to Claude settings
 `);
   write(`
 `);