@intentius/chant 0.0.14 → 0.0.15

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@intentius/chant",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "license": "Apache-2.0",
   "type": "module",
-  "files": ["src/", "bin/"],
+  "files": [
+    "src/",
+    "bin/"
+  ],
   "publishConfig": {
     "access": "public"
   },
@@ -13,13 +16,16 @@
   "exports": {
     ".": "./src/index.ts",
     "./cli": "./src/cli/index.ts",
-    "./cli/*": "./src/cli/*",
-    "./*": "./src/*"
+    "./cli/*": "./src/cli/*.ts",
+    "./*": "./src/*.ts"
   },
   "dependencies": {
     "fflate": "^0.8.2",
     "picomatch": "^4.0.3",
     "typescript": "^5.5.0",
     "zod": "^4.3.6"
+  },
+  "optionalDependencies": {
+    "tsx": "^4.0.0"
   }
 }

package/src/cli/commands/check-lexicon.ts

@@ -208,6 +208,35 @@ export function checkLexicon(dir: string): CheckResult {
     detail: `${mdxFiles.length} page(s)`,
   });
 
+  // Post-synth check count (excluding helpers, tests, and support files)
+  const postSynthCheckFiles = listTsFiles(join(dir, "src/lint/post-synth"), ["index.ts"])
+    .filter((f) => !f.endsWith(".test.ts") && !f.endsWith("-helpers.ts") && f !== "helpers.ts" && !f.startsWith("arm-") && !f.startsWith("k8s-"));
+  items.push({
+    name: "At least 15 post-synth checks",
+    tier: 2,
+    pass: postSynthCheckFiles.length >= 15,
+    detail: `${postSynthCheckFiles.length} check(s)`,
+  });
+
+  // Skills count
+  const skillsDir = join(dir, "src/skills");
+  const skillFiles = existsSync(skillsDir) ? readdirSync(skillsDir).filter((f) => f.endsWith(".md")) : [];
+  items.push({
+    name: "At least 3 skills",
+    tier: 2,
+    pass: skillFiles.length >= 3,
+    detail: `${skillFiles.length} skill(s)`,
+  });
+
+  // initTemplates count — check for template branches in plugin.ts
+  const initTemplateBranches = (pluginContent.match(/template\s*===\s*["']/g) || []).length + 1; // +1 for default
+  items.push({
+    name: "At least 3 initTemplates",
+    tier: 2,
+    pass: initTemplateBranches >= 3,
+    detail: `${initTemplateBranches} template(s)`,
+  });
+
   // ── Tier 3: Thoroughness ───────────────────────────────────────
 
   // Each lint rule has a test (per-file or consolidated)
@@ -276,6 +305,24 @@ export function checkLexicon(dir: string): CheckResult {
     pass: hasActions,
   });
 
+  // Validate required names count
+  const validateContent = readOr(join(dir, "src/validate.ts"));
+  const requiredNamesMatches = validateContent.match(/["'][A-Z][a-zA-Z]+["']/g) || [];
+  items.push({
+    name: "validate.ts checks at least 30 required names",
+    tier: 3,
+    pass: requiredNamesMatches.length >= 30,
+    detail: `${requiredNamesMatches.length} required name(s)`,
+  });
+
+  // Composite test file exists
+  const hasCompositeTest = existsSync(join(dir, "src/composites/composites.test.ts"));
+  items.push({
+    name: "Composite test file exists",
+    tier: 3,
+    pass: hasCompositeTest,
+  });
+
   // Examples with tests (per-example or consolidated root test file)
   const examplesDir = join(dir, "examples");
   let examplesWithTests = 0;

package/src/cli/commands/doctor.ts

@@ -147,7 +147,7 @@ export async function doctorCommand(path: string): Promise<DoctorReport> {
     }
   }
 
-  // Check 8: tsconfig.json has paths
+  // Check 8: tsconfig.json does NOT have paths (they break runtime resolution)
   const tsconfigPath = join(projectPath, "tsconfig.json");
   if (existsSync(tsconfigPath)) {
     try {
@@ -156,8 +156,8 @@ export async function doctorCommand(path: string): Promise<DoctorReport> {
       // Strip single-line comments for basic parsing
       const cleaned = raw.replace(/\/\/.*$/gm, "");
       const tsconfig = JSON.parse(cleaned);
-      if (!tsconfig.compilerOptions?.paths) {
-        checks.push({ name: "tsconfig-paths", status: "warn", message: "tsconfig.json missing compilerOptions.paths" });
+      if (tsconfig.compilerOptions?.paths) {
+        checks.push({ name: "tsconfig-paths", status: "warn", message: "tsconfig.json has compilerOptions.paths — these break runtime module resolution (bun and tsx follow them). Remove the paths block." });
       } else {
         checks.push({ name: "tsconfig-paths", status: "pass" });
       }
@@ -203,10 +203,9 @@ export async function doctorCommand(path: string): Promise<DoctorReport> {
       if (!plugin.skills) continue;
       const skills = plugin.skills();
       if (skills.length === 0) continue;
-      const skillsDir = join(projectPath, ".chant", "skills", plugin.name);
       let missing = 0;
       for (const skill of skills) {
-        if (!existsSync(join(skillsDir, `${skill.name}.md`))) {
+        if (!existsSync(join(projectPath, "skills", skill.name, "SKILL.md"))) {
           missing++;
         }
       }

package/src/cli/commands/init.test.ts

@@ -94,7 +94,7 @@ describe("initCommand", () => {
     });
   });
 
-  test("generates valid tsconfig.json with path mappings", async () => {
+  test("generates valid tsconfig.json without path mappings", async () => {
     await withTestDir(async (testDir) => {
       const options: InitOptions = {
         path: testDir,
@@ -114,8 +114,7 @@ describe("initCommand", () => {
       expect(tsconfig.compilerOptions.strict).toBe(true);
       expect(tsconfig.compilerOptions.rootDir).toBe("./src");
       expect(tsconfig.include).toContain("src");
-      expect(tsconfig.compilerOptions.paths["@intentius/chant"]).toEqual(["./.chant/types/core"]);
-      expect(tsconfig.compilerOptions.paths["@intentius/chant-lexicon-aws"]).toEqual(["./.chant/types/lexicon-aws"]);
+      expect(tsconfig.compilerOptions.paths).toBeUndefined();
     });
   });
 

package/src/cli/commands/init.ts

@@ -61,6 +61,16 @@ export interface InitResult {
   error?: string;
 }
 
+/**
+ * Detect whether the user's project uses bun or npm.
+ * Checks for lock files first, then falls back to runtime detection.
+ */
+function detectPackageManager(dir?: string): "bun" | "npm" {
+  if (dir && (existsSync(join(dir, "bun.lockb")) || existsSync(join(dir, "bun.lock")))) return "bun";
+  if (typeof globalThis.Bun !== "undefined") return "bun";
+  return "npm";
+}
+
 /**
  * Detect the IDE environment for MCP config
  */
@@ -142,12 +152,6 @@ function generateTsConfig(lexicon: string): string {
       declaration: true,
       outDir: "./dist",
       rootDir: "./src",
-      paths: {
-        "@intentius/chant": ["./.chant/types/core"],
-        "@intentius/chant/*": ["./.chant/types/core/*"],
-        [`@intentius/chant-lexicon-${lexicon}`]: [`./.chant/types/lexicon-${lexicon}`],
-        [`@intentius/chant-lexicon-${lexicon}/*`]: [`./.chant/types/lexicon-${lexicon}/*`],
-      },
     },
     include: ["src"],
     exclude: ["node_modules", "dist"],
@@ -177,7 +181,7 @@ node_modules/
 .chant/types/
 .chant/meta/
 .chant/rules/
-.chant/skills/
+skills/
 `;
 }
 
@@ -236,11 +240,11 @@ export interface ChantConfig {
 /**
  * Generate MCP config
  */
-function generateMcpConfig(_ide: "claude-code" | "cursor" | "generic"): string {
+function generateMcpConfig(_ide: "claude-code" | "cursor" | "generic", pm: "bun" | "npm"): string {
   const config = {
     mcpServers: {
       chant: {
-        command: "npx",
+        command: pm === "bun" ? "bunx" : "npx",
         args: ["chant", "serve", "mcp"],
       },
     },
@@ -450,7 +454,7 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
 
     writeIfNotExists(
       join(mcpDir, "mcp.json"),
-      generateMcpConfig(ide),
+      generateMcpConfig(ide, detectPackageManager(targetDir)),
       `~/.${ide === "generic" ? "config/mcp" : ide}/mcp.json`,
       createdFiles,
       warnings,
@@ -458,28 +462,16 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
   }
 
   // Install skills from the lexicon's plugin
-  // Write to both .chant/skills/ (chant's own location) and .claude/skills/ (Claude Code discovery)
   try {
     const plugin = await loadPlugin(options.lexicon);
     if (plugin.skills) {
       const skills = plugin.skills();
       if (skills.length > 0) {
-        // .chant/skills/ — chant's own skill storage
-        const chantSkillsDir = join(targetDir, ".chant", "skills", options.lexicon);
-        mkdirSync(chantSkillsDir, { recursive: true });
         for (const skill of skills) {
-          const skillPath = join(chantSkillsDir, `${skill.name}.md`);
-          writeFileSync(skillPath, skill.content);
-          createdFiles.push(`.chant/skills/${options.lexicon}/${skill.name}.md`);
-        }
-
-        // .claude/skills/ — Claude Code skill discovery format
-        for (const skill of skills) {
-          const claudeSkillDir = join(targetDir, ".claude", "skills", skill.name);
-          mkdirSync(claudeSkillDir, { recursive: true });
-          const claudeSkillPath = join(claudeSkillDir, "SKILL.md");
-          writeFileSync(claudeSkillPath, skill.content);
-          createdFiles.push(`.claude/skills/${skill.name}/SKILL.md`);
+          const skillDir = join(targetDir, "skills", skill.name);
+          mkdirSync(skillDir, { recursive: true });
+          writeFileSync(join(skillDir, "SKILL.md"), skill.content);
+          createdFiles.push(`skills/${skill.name}/SKILL.md`);
         }
       }
     }
@@ -519,6 +511,8 @@ export async function printInitResult(
 
   console.log("");
 
+  const pm = detectPackageManager(options?.cwd);
+
   // Interactive install prompt
   if (!options?.skipInstall) {
     const shouldInstall = await promptInstall();
@@ -527,9 +521,9 @@ export async function printInitResult(
       const cwd = options?.cwd ?? ".";
       console.log("Installing dependencies...");
       try {
-        execSync("npm install", { cwd, stdio: "inherit" });
+        execSync(`${pm} install`, { cwd, stdio: "inherit" });
       } catch {
-        console.error(formatWarning({ message: "Install failed. Run 'npm install' manually." }));
+        console.error(formatWarning({ message: `Install failed. Run '${pm} install' manually.` }));
       }
     }
   }
@@ -538,6 +532,6 @@ export async function printInitResult(
   console.log("Next steps:");
   console.log("  1. Edit src/config.ts");
   console.log("  2. Add resources in src/");
-  console.log("  3. npm run build");
+  console.log(`  3. ${pm} run build`);
 }
 

package/src/cli/commands/update.ts

@@ -164,10 +164,10 @@ export async function updateCommand(options: UpdateOptions): Promise<UpdateResul
       if (plugin.skills) {
         const skills = plugin.skills();
         if (skills.length > 0) {
-          const skillsDir = join(projectDir, ".chant", "skills", plugin.name);
-          mkdirSync(skillsDir, { recursive: true });
           for (const skill of skills) {
-            writeFileSync(join(skillsDir, `${skill.name}.md`), skill.content);
+            const skillDir = join(projectDir, "skills", skill.name);
+            mkdirSync(skillDir, { recursive: true });
+            writeFileSync(join(skillDir, "SKILL.md"), skill.content);
           }
           synced.push(`${plugin.name} skills (${skills.length})`);
         }

package/src/codegen/generate-typescript.ts

@@ -102,9 +102,12 @@ export function writeConstructor(
     const optional = p.required ? "" : "?";
     const tsType = resolveConstructorType(p.type, remap);
     if (p.description) {
-      lines.push(`    /** ${p.description} */`);
+      // Sanitize: escape */ to prevent breaking JSDoc comments
+      const safeDesc = p.description.replace(/\*\//g, "*\\/");
+      lines.push(`    /** ${safeDesc} */`);
     }
-    lines.push(`    ${p.name}${optional}: ${tsType};`);
+    const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
+    lines.push(`    ${safeName}${optional}: ${tsType};`);
   }
   if (resourceAttributesType) {
     lines.push(`  }, attributes?: ${resourceAttributesType});`);

package/src/serializer-walker.test.ts

@@ -101,6 +101,29 @@ describe("walkValue", () => {
     expect(walkValue((resource as any).Ref, names, mockVisitor)).toEqual({ __ref: "MyTable" });
   });
 
+  test("resolves __attrRef envelope inside intrinsic toJSON output", () => {
+    // Simulate an intrinsic whose toJSON() produces an __attrRef envelope
+    // (e.g., AttrRef inside a Sub template literal)
+    const intrinsic = {
+      [INTRINSIC_MARKER]: true as const,
+      toJSON: () => ({
+        MyIntrinsic: { __attrRef: { entity: "MyResource", attribute: "Arn" } },
+      }),
+    };
+    const names = new Map<Declarable, string>();
+    expect(walkValue(intrinsic, names, mockVisitor)).toEqual({
+      MyIntrinsic: { __getAtt: ["MyResource", "Arn"] },
+    });
+  });
+
+  test("resolves standalone __attrRef envelope in plain object", () => {
+    const names = new Map<Declarable, string>();
+    const value = { __attrRef: { entity: "MyBucket", attribute: "DomainName" } };
+    expect(walkValue(value, names, mockVisitor)).toEqual({
+      __getAtt: ["MyBucket", "DomainName"],
+    });
+  });
+
   test("complex nested structure", () => {
     const resource = makeDeclarable("Test::Role");
     const ref = new AttrRef(resource, "arn");

package/src/serializer-walker.ts

@@ -43,10 +43,10 @@ export function walkValue(
     return visitor.attrRef(name, value.attribute);
   }
 
-  // Handle Intrinsics
+  // Handle Intrinsics — walk the toJSON() result to resolve any embedded AttrRef markers
   if (typeof value === "object" && value !== null && INTRINSIC_MARKER in value) {
     if ("toJSON" in value && typeof value.toJSON === "function") {
-      return value.toJSON();
+      return walkValue(value.toJSON(), entityNames, visitor);
     }
   }
 
@@ -67,6 +67,12 @@ export function walkValue(
     return value.map((item) => walkValue(item, entityNames, visitor));
   }
 
+  // Handle serialized AttrRef envelopes (produced by AttrRef.toJSON() inside intrinsics)
+  if (typeof value === "object" && "__attrRef" in value) {
+    const ref = (value as { __attrRef: { entity: string; attribute: string } }).__attrRef;
+    return visitor.attrRef(ref.entity, ref.attribute);
+  }
+
   // Handle objects
   if (typeof value === "object") {
     const result: Record<string, unknown> = {};

package/src/yaml.test.ts

@@ -88,6 +88,27 @@ describe("emitYAML", () => {
     const result = emitYAML({ key: "val" }, 1);
     expect(result).toBe("\n  key: val");
   });
+
+  test("multiline string emits as | block scalar", () => {
+    const result = emitYAML("line1\nline2\nline3", 0);
+    expect(result).toBe("|\nline1\nline2\nline3");
+  });
+
+  test("multiline string trims trailing empty line", () => {
+    // Template literals often end with \n producing a trailing empty line
+    const result = emitYAML("line1\nline2\n", 0);
+    expect(result).toBe("|\nline1\nline2");
+  });
+
+  test("multiline string inside object value is properly indented", () => {
+    const result = emitYAML({ config: "line1\nline2\nline3" }, 0);
+    expect(result).toContain("config: |\n  line1\n  line2\n  line3");
+  });
+
+  test("multiline string inside array item is properly indented", () => {
+    const result = emitYAML([{ data: "a\nb" }], 0);
+    expect(result).toContain("data: |\n    a\n    b");
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/yaml.ts

@@ -35,6 +35,13 @@ export function emitYAML(value: unknown, indent: number): string {
   }
 
   if (typeof value === "string") {
+    // Multiline strings use YAML literal block scalar (|)
+    if (value.includes("\n")) {
+      const lines = value.split("\n");
+      // Trim trailing empty line if present (common for template strings)
+      const trimmed = lines[lines.length - 1] === "" ? lines.slice(0, -1) : lines;
+      return "|\n" + trimmed.map((l) => `${prefix}${l}`).join("\n");
+    }
     // Quote strings that could be misinterpreted
     if (
       value === "" ||
@@ -225,6 +232,58 @@ export function parseYAMLLines(
   return { value: result, endIndex: i };
 }
 
+/**
+ * Parse the value of a key inside an array item.
+ * If the inline value is empty, look ahead for a nested object or array.
+ */
+function parseArrayItemValue(
+  inlineValue: string,
+  lines: string[],
+  currentIndex: number,
+  childIndent: number,
+): unknown {
+  if (inlineValue !== "" && !inlineValue.startsWith("#")) {
+    if (inlineValue.startsWith("[")) {
+      try { return JSON.parse(inlineValue); } catch { return inlineValue; }
+    }
+    if (inlineValue.startsWith("{")) {
+      try { return JSON.parse(inlineValue); } catch { return inlineValue; }
+    }
+    return parseScalar(inlineValue);
+  }
+  // Empty inline value — check for nested block
+  const nextIdx = currentIndex + 1;
+  if (nextIdx < lines.length) {
+    const nextLine = lines[nextIdx];
+    if (nextLine.trim() !== "" && !nextLine.trim().startsWith("#")) {
+      const ni = nextLine.search(/\S/);
+      if (ni >= childIndent) {
+        if (nextLine.trimStart().startsWith("- ")) {
+          return parseYAMLArray(lines, nextIdx, ni).value;
+        }
+        return parseYAMLLines(lines, nextIdx, ni).value;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Skip past a nested block (object or array) starting at startIndex with the given indent.
+ * Returns the index of the first line that is NOT part of the nested block.
+ */
+function skipNestedBlock(lines: string[], startIndex: number, childIndent: number): number {
+  let j = startIndex;
+  while (j < lines.length) {
+    const l = lines[j];
+    if (l.trim() === "" || l.trim().startsWith("#")) { j++; continue; }
+    const ni = l.search(/\S/);
+    if (ni < childIndent) break;
+    j++;
+  }
+  return j;
+}
+
 /**
  * Parse a block array (lines starting with `- `).
  */
@@ -253,10 +312,12 @@ export function parseYAMLArray(
       const kvMatch = itemValue.match(/^([^\s:][^:]*?):\s*(.*)$/);
       if (kvMatch) {
         const obj: Record<string, unknown> = {};
-        obj[kvMatch[1].trim()] = parseScalar(kvMatch[2].trim());
+        obj[kvMatch[1].trim()] = parseArrayItemValue(kvMatch[2].trim(), lines, i, indent + 2);
         // Check for more keys at indent+2
         const nextIndent = indent + 2;
-        let j = i + 1;
+        let j = kvMatch[2].trim() === "" || kvMatch[2].trim().startsWith("#")
+          ? skipNestedBlock(lines, i + 1, nextIndent)
+          : i + 1;
         while (j < lines.length) {
           const nextLine = lines[j];
           if (nextLine.trim() === "" || nextLine.trim().startsWith("#")) {
@@ -264,11 +325,17 @@ export function parseYAMLArray(
             continue;
           }
           const ni = nextLine.search(/\S/);
-          if (ni !== nextIndent) break;
+          if (ni < nextIndent) break;
+          if (ni > nextIndent) break; // belongs to a nested block already consumed
           const nextKV = nextLine.match(/^(\s*)([^\s:][^:]*?):\s*(.*)$/);
           if (nextKV) {
-            obj[nextKV[2].trim()] = parseScalar(nextKV[3].trim());
-            j++;
+            const nextVal = nextKV[3].trim();
+            obj[nextKV[2].trim()] = parseArrayItemValue(nextVal, lines, j, ni + 2);
+            if (nextVal === "" || nextVal.startsWith("#")) {
+              j = skipNestedBlock(lines, j + 1, ni + 2);
+            } else {
+              j++;
+            }
           } else {
             break;
           }