@hasna/instructions 0.4.8 → 0.4.9

package/dist/mcp/index.js

@@ -5359,8 +5359,12 @@ var init_redact = __esm(() => {
 });
 
 // src/lib/session-render-contract.ts
-var SESSION_RENDER_SCHEMA = "hasna.configs.session-render/v1";
-var init_session_render_contract = () => {};
+var SESSION_RENDER_SCHEMA = "hasna.configs.session-render/v1", SESSION_RENDER_MANAGED_NAMESPACE = ".hasna", SESSION_RENDER_INSTRUCTIONS_MANAGED_DIR, SESSION_RENDER_MANIFEST_RELATIVE_PATH, SESSION_RENDER_SNAPSHOT_RELATIVE_DIR;
+var init_session_render_contract = __esm(() => {
+  SESSION_RENDER_INSTRUCTIONS_MANAGED_DIR = `${SESSION_RENDER_MANAGED_NAMESPACE}/instructions`;
+  SESSION_RENDER_MANIFEST_RELATIVE_PATH = `${SESSION_RENDER_MANAGED_NAMESPACE}/session-render-manifest.json`;
+  SESSION_RENDER_SNAPSHOT_RELATIVE_DIR = `${SESSION_RENDER_MANAGED_NAMESPACE}/session-render-snapshots`;
+});
 
 // src/lib/project-context.ts
 import { basename, dirname, isAbsolute, join as join3, parse, relative, resolve } from "path";
@@ -5645,7 +5649,7 @@ function applyTransform(source, output, context = {}) {
 var init_transforms = () => {};
 
 // src/lib/session-render.ts
-var ANTIGRAVITY_RULE_FILE_CHAR_LIMIT = 12000, SESSION_RENDERER_OWNER_ID = "instructions-session-renderer", SESSION_RENDER_PROFILE_ENTRYPOINTS, SESSION_RENDER_OWNED_CONFIG_TARGETS;
+var ANTIGRAVITY_RULE_FILE_CHAR_LIMIT = 12000, SESSION_RENDERER_OWNER_ID = "instructions-session-renderer", SESSION_RENDER_PROFILE_ENTRYPOINTS, SESSION_RENDER_OWNED_CONFIG_TARGETS, CODEWITH_FLATTENED_ADAPTER, CODEWITH_NATIVE_ADAPTER, SESSION_TOOL_ADAPTERS, SESSION_RENDER_MANAGED_DIRS, SESSION_RENDER_SHARED_MANAGED_DIRS, SESSION_RENDER_EXCLUSIVE_MANAGED_PATHS;
 var init_session_render = __esm(() => {
   init_global_agent_rules_standard();
   init_project_context();
@@ -5664,6 +5668,174 @@ var init_session_render = __esm(() => {
     ".gemini/GEMINI.md",
     ".gemini/ANTIGRAVITY.md"
   ];
+  CODEWITH_FLATTENED_ADAPTER = {
+    tool: "codewith",
+    mode: "flattened-markdown",
+    indexFile: "CODEWITH.md",
+    managedDir: SESSION_RENDER_INSTRUCTIONS_MANAGED_DIR,
+    envVar: "CODEWITH_HOME",
+    nativeImports: false,
+    description: "Codewith CODEWITH.md flattened until native @ imports are implemented in Codewith."
+  };
+  CODEWITH_NATIVE_ADAPTER = {
+    tool: "codewith",
+    mode: "native-imports",
+    indexFile: "CODEWITH.md",
+    managedDir: SESSION_RENDER_INSTRUCTIONS_MANAGED_DIR,
+    envVar: "CODEWITH_HOME",
+    nativeImports: true,
+    description: "Codewith CODEWITH.md with gated @ imports into managed fragments."
+  };
+  SESSION_TOOL_ADAPTERS = {
+    claude: {
+      tool: "claude",
+      mode: "native-imports",
+      indexFile: "CLAUDE.md",
+      managedDir: SESSION_RENDER_INSTRUCTIONS_MANAGED_DIR,
+      envVar: "CLAUDE_CONFIG_DIR",
+      nativeImports: true,
+      description: "Claude Code CLAUDE.md with @ imports into managed fragments."
+    },
+    codex: {
+      tool: "codex",
+      mode: "flattened-markdown",
+      indexFile: "AGENTS.md",
+      managedDir: SESSION_RENDER_INSTRUCTIONS_MANAGED_DIR,
+      envVar: "CODEX_HOME",
+      nativeImports: false,
+      description: "Codex AGENTS.md flattened instruction file."
+    },
+    cursor: {
+      tool: "cursor",
+      mode: "cursor-mdc",
+      managedDir: ".cursor/rules",
+      nativeImports: false,
+      description: "Cursor project rule files in .cursor/rules/*.mdc."
+    },
+    opencode: {
+      tool: "opencode",
+      mode: "opencode-instructions",
+      indexFile: "AGENTS.md",
+      configFile: "opencode.json",
+      managedDir: SESSION_RENDER_INSTRUCTIONS_MANAGED_DIR,
+      envVar: "OPENCODE_CONFIG_DIR",
+      nativeImports: false,
+      description: "OpenCode AGENTS.md plus opencode.json instructions pointing at managed fragments."
+    },
+    aicopilot: {
+      tool: "aicopilot",
+      mode: "flattened-markdown",
+      indexFile: "AICOPILOT.md",
+      managedDir: SESSION_RENDER_INSTRUCTIONS_MANAGED_DIR,
+      envVar: "AICOPILOT_CONFIG_DIR",
+      nativeImports: false,
+      description: "AI Copilot AICOPILOT.md flattened instruction file."
+    },
+    qwen: {
+      tool: "qwen",
+      mode: "flattened-markdown",
+      indexFile: "QWEN.md",
+      managedDir: ".qwen/instructions",
+      envVar: "QWEN_HOME",
+      nativeImports: false,
+      description: "Qwen Code QWEN.md hierarchical instructional context file."
+    },
+    antigravity: {
+      tool: "antigravity",
+      mode: "antigravity-rules",
+      managedDir: ".agents/rules",
+      nativeImports: false,
+      description: "Google Antigravity project rules in .agents/rules/*.md."
+    },
+    codewith: CODEWITH_FLATTENED_ADAPTER
+  };
+  SESSION_RENDER_MANAGED_DIRS = [
+    ...new Set([
+      CODEWITH_FLATTENED_ADAPTER,
+      CODEWITH_NATIVE_ADAPTER,
+      ...Object.values(SESSION_TOOL_ADAPTERS)
+    ].map((adapter) => adapter.managedDir))
+  ];
+  SESSION_RENDER_SHARED_MANAGED_DIRS = [".cursor/rules"];
+  SESSION_RENDER_EXCLUSIVE_MANAGED_PATHS = [
+    ...SESSION_RENDER_MANAGED_DIRS.filter((dir) => !SESSION_RENDER_SHARED_MANAGED_DIRS.includes(dir)),
+    SESSION_RENDER_MANIFEST_RELATIVE_PATH,
+    SESSION_RENDER_SNAPSHOT_RELATIVE_DIR
+  ];
+});
+
+// src/lib/session-render-ownership.ts
+import { existsSync as existsSync3, readFileSync, statSync } from "fs";
+import { dirname as dirname2, join as join4, parse as parse2, relative as relative2, sep } from "path";
+function toSegments(absolutePath2) {
+  return absolutePath2.replaceAll("\\", "/").split("/").filter(Boolean);
+}
+function pathIsSessionRenderManagedDir(absolutePath2) {
+  const segments = toSegments(absolutePath2);
+  return MANAGED_PATH_SEGMENTS.some((managed) => {
+    if (managed.length === 0 || managed.length > segments.length)
+      return false;
+    for (let start = 0;start + managed.length <= segments.length; start += 1) {
+      if (managed.every((segment, offset) => segments[start + offset] === segment))
+        return true;
+    }
+    return false;
+  });
+}
+function readManifestRelativePaths(manifestPath) {
+  let stats;
+  try {
+    if (!existsSync3(manifestPath))
+      return null;
+    stats = statSync(manifestPath);
+  } catch {
+    return null;
+  }
+  const cached = manifestCache.get(manifestPath);
+  if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) {
+    return cached.relativePaths;
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+  } catch {
+    return null;
+  }
+  if (manifest?.schema !== SESSION_RENDER_SCHEMA || !Array.isArray(manifest.files))
+    return null;
+  const writerId = manifest.targetOwner?.writer?.id;
+  if (writerId !== undefined && writerId !== SESSION_RENDERER_OWNER_ID)
+    return null;
+  const relativePaths = new Set(manifest.files.map((file) => file?.relativePath).filter((relativePath) => typeof relativePath === "string").map((relativePath) => relativePath.replaceAll("\\", "/")));
+  manifestCache.set(manifestPath, { mtimeMs: stats.mtimeMs, size: stats.size, relativePaths });
+  return relativePaths;
+}
+function sessionRenderManifestClaimsPath(absolutePath2) {
+  const root = parse2(absolutePath2).root;
+  let home = dirname2(absolutePath2);
+  for (let depth = 0;depth < MANIFEST_ANCESTOR_LIMIT; depth += 1) {
+    const manifestPath = join4(home, ...SESSION_RENDER_MANIFEST_RELATIVE_PATH.split("/"));
+    const relativePaths = readManifestRelativePaths(manifestPath);
+    if (relativePaths) {
+      const claimed = relative2(home, absolutePath2).split(sep).join("/");
+      if (relativePaths.has(claimed))
+        return true;
+    }
+    const parent = dirname2(home);
+    if (parent === home || home === root)
+      break;
+    home = parent;
+  }
+  return false;
+}
+function sessionRenderOwnsPath(absolutePath2) {
+  return pathIsSessionRenderManagedDir(absolutePath2) || sessionRenderManifestClaimsPath(absolutePath2);
+}
+var MANIFEST_ANCESTOR_LIMIT = 24, MANAGED_PATH_SEGMENTS, manifestCache;
+var init_session_render_ownership = __esm(() => {
+  init_session_render();
+  MANAGED_PATH_SEGMENTS = SESSION_RENDER_EXCLUSIVE_MANAGED_PATHS.map((managedPath) => managedPath.split("/").filter(Boolean));
+  manifestCache = new Map;
 });
 
 // src/lib/apply.ts
@@ -5677,8 +5849,8 @@ __export(exports_apply, {
   applyConfigs: () => applyConfigs,
   applyConfig: () => applyConfig
 });
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync, realpathSync, writeFileSync } from "fs";
-import { basename as basename3, dirname as dirname2, join as join4, resolve as resolve2 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, realpathSync, writeFileSync } from "fs";
+import { basename as basename3, dirname as dirname3, join as join5, resolve as resolve2 } from "path";
 import { homedir as homedir2 } from "os";
 function getConfigHome() {
   return process.env["CONFIGS_HOME"] || process.env["HOME"] || homedir2();
@@ -5697,14 +5869,14 @@ function normalizeTargetPath(p) {
     let current = expanded;
     const missingSegments = [];
     while (true) {
-      if (existsSync3(current)) {
+      if (existsSync4(current)) {
         try {
           return resolve2(realpathSync(current), ...missingSegments);
         } catch {
           return expanded;
         }
       }
-      const parent = dirname2(current);
+      const parent = dirname3(current);
       const name = basename3(current);
       if (parent === current)
         return expanded;
@@ -5726,11 +5898,11 @@ async function writeConfigResult(config, targetPath, content, opts, meta = {}) {
     throw new ConfigApplyError(`Antigravity rule file ${renderedTargetPath} is ${renderedContent.length} characters; split it before applying because Antigravity limits rule files to ${ANTIGRAVITY_RULE_FILE_CHAR_LIMIT} characters.`);
   }
   const path = expandPath(renderedTargetPath);
-  const previousContent = existsSync3(path) ? readFileSync(path, "utf-8") : null;
+  const previousContent = existsSync4(path) ? readFileSync2(path, "utf-8") : null;
   const changed = previousContent !== renderedContent;
   if (!opts.dryRun) {
-    const dir = dirname2(path);
-    if (!existsSync3(dir)) {
+    const dir = dirname3(path);
+    if (!existsSync4(dir)) {
       mkdirSync2(dir, { recursive: true });
     }
     if (previousContent !== null && changed) {
@@ -6033,13 +6205,15 @@ function sessionRendererOwnsTarget(targetPath, opts) {
   return sessionRendererOwnsCanonicalTarget(canonicalApplyTargetPath(targetPath, opts), opts);
 }
 function sessionRendererOwnsCanonicalTarget(normalized, opts) {
+  if (opts.allowSessionRendererOwned)
+    return false;
   const homes = new Set([
     getConfigHome(),
     opts.vars?.["HOME_DIR"]
   ].filter((home) => typeof home === "string" && home.length > 0));
-  if ([...homes].some((home) => SESSION_RENDER_OWNED_CONFIG_TARGETS.some((relativePath) => normalized === normalizeTargetPath(join4(home, ...relativePath.split("/"))))))
+  if ([...homes].some((home) => SESSION_RENDER_OWNED_CONFIG_TARGETS.some((relativePath) => normalized === normalizeTargetPath(join5(home, ...relativePath.split("/"))))))
     return true;
-  return normalized.replaceAll("\\", "/").includes("/.agents/rules/");
+  return sessionRenderOwnsPath(normalized);
 }
 var init_apply = __esm(() => {
   init_types();
@@ -6047,6 +6221,7 @@ var init_apply = __esm(() => {
   init_config_agents();
   init_machine();
   init_session_render();
+  init_session_render_ownership();
   init_transforms();
 });
 
@@ -6066,8 +6241,8 @@ __export(exports_sync, {
   KNOWN_CONFIGS: () => KNOWN_CONFIGS,
   CLAUDE_PROMPT_OUTPUTS: () => CLAUDE_PROMPT_OUTPUTS
 });
-import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync2 } from "fs";
-import { basename as basename4, extname as extname2, join as join5 } from "path";
+import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync3 } from "fs";
+import { basename as basename4, extname as extname2, join as join6 } from "path";
 function claudeRuleOutputs(fileName) {
   const stem = basename4(fileName, extname2(fileName));
   return [
@@ -6099,7 +6274,7 @@ function isGeneratedOutputTarget2(config, owners) {
   return !!ownerIds && !ownerIds.has(config.id);
 }
 function hasClaudePromptSource() {
-  return existsSync4(expandPath("~/.claude/CLAUDE.md"));
+  return existsSync5(expandPath("~/.claude/CLAUDE.md"));
 }
 function hasClaudeRuleSourceForCursorTarget(targetPath) {
   const absoluteTargetPath = expandPath(targetPath);
@@ -6107,7 +6282,7 @@ function hasClaudeRuleSourceForCursorTarget(targetPath) {
   if (!absoluteTargetPath.startsWith(`${absolutePrefix}/`) || !absoluteTargetPath.endsWith(".mdc"))
     return false;
   const stem = basename4(absoluteTargetPath, ".mdc");
-  return existsSync4(expandPath(`~/.claude/rules/${stem}.md`)) || existsSync4(expandPath(`~/.claude/rules/${stem}.mdc`));
+  return existsSync5(expandPath(`~/.claude/rules/${stem}.md`)) || existsSync5(expandPath(`~/.claude/rules/${stem}.mdc`));
 }
 function isKnownGeneratedTargetPath(targetPath) {
   const normalizedTargetPath = normalizeTargetPath(targetPath);
@@ -6124,11 +6299,11 @@ async function syncProject(opts) {
   const allConfigs = await store.listConfigs();
   const machine = detectMachineContext();
   for (const pf of PROJECT_CONFIG_FILES) {
-    const abs = join5(absDir, pf.file);
-    if (!existsSync4(abs))
+    const abs = join6(absDir, pf.file);
+    if (!existsSync5(abs))
       continue;
     try {
-      const rawContent = readFileSync2(abs, "utf-8");
+      const rawContent = readFileSync3(abs, "utf-8");
       if (rawContent.length > 500000) {
         result.skipped.push(pf.file);
         continue;
@@ -6157,15 +6332,15 @@ async function syncProject(opts) {
     }
   }
   for (const ruleDir of [
-    { dir: join5(absDir, ".claude", "rules"), agent: "claude", namePrefix: "rules" },
-    { dir: join5(absDir, ".agents", "rules"), agent: "antigravity", namePrefix: "antigravity-rules" }
+    { dir: join6(absDir, ".claude", "rules"), agent: "claude", namePrefix: "rules" },
+    { dir: join6(absDir, ".agents", "rules"), agent: "antigravity", namePrefix: "antigravity-rules" }
   ]) {
-    if (!existsSync4(ruleDir.dir))
+    if (!existsSync5(ruleDir.dir))
       continue;
     const mdFiles = readdirSync(ruleDir.dir).filter((f) => f.endsWith(".md") || f.endsWith(".mdc"));
     for (const f of mdFiles) {
-      const abs = join5(ruleDir.dir, f);
-      const raw = readFileSync2(abs, "utf-8");
+      const abs = join6(ruleDir.dir, f);
+      const raw = readFileSync3(abs, "utf-8");
       const redacted = redactContent(raw, "markdown");
       const machineAware = templateizeMachineContent(redacted.content, machine);
       const content = machineAware.content;
@@ -6204,20 +6379,20 @@ async function syncKnown(opts = {}) {
   for (const known of targets) {
     if (known.rulesDir) {
       const absDir = expandPath(known.rulesDir);
-      if (!existsSync4(absDir)) {
+      if (!existsSync5(absDir)) {
         result.skipped.push(known.rulesDir);
         continue;
       }
       const extensions = known.rulesExtensions ?? [".md", ".mdc"];
       const ruleFiles = readdirSync(absDir).filter((f) => extensions.some((ext) => f.endsWith(ext)));
       for (const f of ruleFiles) {
-        const abs2 = join5(absDir, f);
+        const abs2 = join6(absDir, f);
         const targetPath = abs2.replace(home, "~");
         if (existingOutputOwners.has(normalizeTargetPath(targetPath)) || isKnownGeneratedTargetPath(targetPath)) {
           result.skipped.push(`${targetPath} (generated output)`);
           continue;
         }
-        const raw = readFileSync2(abs2, "utf-8");
+        const raw = readFileSync3(abs2, "utf-8");
         const redacted = redactContent(raw, "markdown");
         const machineAware = templateizeMachineContent(redacted.content, machine);
         const content = machineAware.content;
@@ -6245,12 +6420,12 @@ async function syncKnown(opts = {}) {
       continue;
     }
     const abs = expandPath(known.path);
-    if (!existsSync4(abs)) {
+    if (!existsSync5(abs)) {
       result.skipped.push(known.path);
       continue;
     }
     try {
-      const rawContent = readFileSync2(abs, "utf-8");
+      const rawContent = readFileSync3(abs, "utf-8");
       if (rawContent.length > 500000) {
         result.skipped.push(known.path + " (too large)");
         continue;
@@ -6338,9 +6513,9 @@ async function syncToDisk(opts = {}) {
 }
 function buildDiff(expectedContent, targetPath) {
   const path = expandPath(targetPath);
-  if (!existsSync4(path))
+  if (!existsSync5(path))
     return `(file not found on disk: ${path})`;
-  const diskContent = readFileSync2(path, "utf-8");
+  const diskContent = readFileSync3(path, "utf-8");
   if (diskContent === expectedContent)
     return "(no diff \u2014 identical)";
   const stored = expectedContent.split(`
@@ -6520,8 +6695,8 @@ var init_sync = __esm(() => {
 });
 
 // src/lib/sync-dir.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync } from "fs";
-import { join as join6, relative as relative2 } from "path";
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { join as join7, relative as relative3 } from "path";
 import { homedir as homedir3 } from "os";
 function shouldSkip(p) {
   return SKIP.some((s) => p.includes(s));
@@ -6529,9 +6704,9 @@ function shouldSkip(p) {
 async function syncFromDir(dir, opts = {}) {
   const store = opts.store ?? resolveConfigStore();
   const absDir = expandPath(dir);
-  if (!existsSync5(absDir))
+  if (!existsSync6(absDir))
     return { added: 0, updated: 0, unchanged: 0, skipped: [`Not found: ${absDir}`] };
-  const files = opts.recursive !== false ? walkDir(absDir) : readdirSync2(absDir).map((f) => join6(absDir, f)).filter((f) => statSync(f).isFile());
+  const files = opts.recursive !== false ? walkDir(absDir) : readdirSync2(absDir).map((f) => join7(absDir, f)).filter((f) => statSync2(f).isFile());
   const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
   const home = homedir3();
   const allConfigs = await store.listConfigs();
@@ -6541,7 +6716,7 @@ async function syncFromDir(dir, opts = {}) {
       continue;
     }
     try {
-      const content = readFileSync3(file, "utf-8");
+      const content = readFileSync4(file, "utf-8");
       if (content.length > 500000) {
         result.skipped.push(file + " (too large)");
         continue;
@@ -6550,7 +6725,7 @@ async function syncFromDir(dir, opts = {}) {
       const existing = allConfigs.find((c) => c.target_path === targetPath);
       if (!existing) {
         if (!opts.dryRun)
-          await store.createConfig({ name: relative2(absDir, file), category: detectCategory(file), agent: detectAgent(file), target_path: targetPath, format: detectFormat(file), content });
+          await store.createConfig({ name: relative3(absDir, file), category: detectCategory(file), agent: detectAgent(file), target_path: targetPath, format: detectFormat(file), content });
         result.added++;
       } else if (existing.content !== content) {
         if (!opts.dryRun)
@@ -6591,7 +6766,7 @@ async function syncToDir(dir, opts = {}) {
 }
 function walkDir(dir, files = []) {
   for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-    const full = join6(dir, entry.name);
+    const full = join7(dir, entry.name);
     if (shouldSkip(full))
       continue;
     if (entry.isDirectory())
@@ -6613,7 +6788,7 @@ var init_sync_dir = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@hasna/instructions",
-    version: "0.4.8",
+    version: "0.4.9",
     description: "AI coding agent instruction & configuration manager \u2014 store, version, apply, and share all your AI coding configs. CLI + MCP + HTTP API (instructions-serve) + generated SDK + Dashboard.",
     type: "module",
     main: "dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/instructions",
-  "version": "0.4.8",
+  "version": "0.4.9",
   "description": "AI coding agent instruction & configuration manager \u2014 store, version, apply, and share all your AI coding configs. CLI + MCP + HTTP API (instructions-serve) + generated SDK + Dashboard.",
   "type": "module",
   "main": "dist/index.js",