@shrkcrft/importer 0.1.0-alpha.31 → 0.1.0-alpha.32

package/dist/api/import-cursor-rules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"import-cursor-rules.d.ts","sourceRoot":"","sources":["../../src/api/import-cursor-rules.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAkB,MAAM,2BAA2B,CAAC;AAI/E,MAAM,WAAW,yBAAyB;IACxC,6DAA6D;IAC7D,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mDAAmD;IACnD,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,qDAAqD;IACrD,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B;AA6BD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,yBAAyB,GAAG,aAAa,CAoDnF"}
+{"version":3,"file":"import-cursor-rules.d.ts","sourceRoot":"","sources":["../../src/api/import-cursor-rules.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAkB,MAAM,2BAA2B,CAAC;AAI/E,MAAM,WAAW,yBAAyB;IACxC,6DAA6D;IAC7D,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mDAAmD;IACnD,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,qDAAqD;IACrD,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B;AA6BD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,yBAAyB,GAAG,aAAa,CAuDnF"}

package/dist/api/import-cursor-rules.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import * as nodePath from 'node:path';
-import { parseCursorRuleFile } from "../parse/parse-cursor-rule.js";
+import { parseCursorRule } from "../parse/parse-cursor-rule.js";
 import { slugify } from "../parse/slugify.js";
 function walkMdcFiles(start) {
     const out = [];
@@ -56,7 +56,11 @@ export function importCursorRules(options) {
         const origin = nodePath.relative(root, file) || nodePath.basename(file);
         const base = nodePath.basename(file).replace(/\.(mdc|md)$/i, '');
         const idPrefix = `${basePrefix}.${slugify(base) || 'rule'}`;
-        const entry = parseCursorRuleFile(raw, { origin, idPrefix });
+        const { entry, problems } = parseCursorRule(raw, { origin, idPrefix });
+        // Frontmatter THE parser could not read as declared is said out loud (round
+        // 15 follow-up, F6) — the old line splitter skipped it without a word.
+        for (const message of problems)
+            warnings.push({ origin, message });
         let id = entry.id;
         let counter = 2;
         while (seenIds.has(id)) {

package/dist/parse/i-cursor-rule-parse.d.ts

@@ -0,0 +1,15 @@
+import type { IImportedEntry } from '../model/imported-entry.js';
+/** One `.mdc` rule read by `parseCursorRule`: the entry, and every reason (part of) its frontmatter was not read. */
+export interface ICursorRuleParse {
+    readonly entry: IImportedEntry;
+    /**
+     * Why frontmatter did not reach the entry — a parse error naming the line
+     * (in the top-level structure, a line naming no key: the whole frontmatter
+     * is ignored; under one key the importer reads: that key alone), a field of
+     * the wrong shape (that field is ignored), an unterminated block. A key the
+     * importer does not read is never parsed. `[]`: read as declared. The
+     * importer surfaces each as a warning; none is silent.
+     */
+    readonly problems: readonly string[];
+}
+//# sourceMappingURL=i-cursor-rule-parse.d.ts.map

package/dist/parse/i-cursor-rule-parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i-cursor-rule-parse.d.ts","sourceRoot":"","sources":["../../src/parse/i-cursor-rule-parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAEjE,qHAAqH;AACrH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC"}

package/dist/parse/i-cursor-rule-parse.js

@@ -0,0 +1 @@
+export {};

package/dist/parse/parse-cursor-rule.d.ts

@@ -1,4 +1,5 @@
 import type { IImportedEntry } from '../model/imported-entry.js';
+import type { ICursorRuleParse } from './i-cursor-rule-parse.js';
 /**
  * Parse a single .cursor/rules/*.mdc file. MDC format = YAML frontmatter
  * (between `---` markers) + markdown body. We extract:
@@ -6,10 +7,27 @@ import type { IImportedEntry } from '../model/imported-entry.js';
  *   - `globs` / `tags` → tags
  *   - `priority` (if present) → KnowledgePriority
  *   - the body → content
+ *
+ * The frontmatter is read by THE parser (`splitFrontmatter` +
+ * `parseFrontmatter`, @shrkcrft/core — round 15 follow-up, F6) in its `Text`
+ * scalar mode: Cursor writes values bare (`globs: *.ts, *.tsx`,
+ * `description: Fix #12`), and they are read verbatim, as the old line
+ * splitter read them. A comma-separated `globs` / `tags` string is read as
+ * THE parser's inline list, so a quoted item or a brace glob (`*.{ts,tsx}`)
+ * stays one item. Only the four keys the importer reads are parsed, each on
+ * its own; any other key is skipped unparsed (`IParseFrontmatterOptions.keys`).
  */
 export interface ICursorRuleOptions {
     origin: string;
     idPrefix: string;
 }
+/**
+ * Parse one `.mdc` rule, with every reason (part of) its frontmatter was not
+ * read — the importer surfaces each as a warning (round 15 follow-up, F6: the
+ * old line splitter skipped an unreadable line, a block list or a whole BOM /
+ * `--- ` file without a word).
+ */
+export declare function parseCursorRule(raw: string, options: ICursorRuleOptions): ICursorRuleParse;
+/** {@link parseCursorRule}'s entry alone (the frontmatter problems are dropped — `importCursorRules` reports them). */
 export declare function parseCursorRuleFile(raw: string, options: ICursorRuleOptions): IImportedEntry;
 //# sourceMappingURL=parse-cursor-rule.d.ts.map

package/dist/parse/parse-cursor-rule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-cursor-rule.d.ts","sourceRoot":"","sources":["../../src/parse/parse-cursor-rule.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAGjE;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAwDD,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,kBAAkB,GAC1B,cAAc,CAqBhB"}
+{"version":3,"file":"parse-cursor-rule.d.ts","sourceRoot":"","sources":["../../src/parse/parse-cursor-rule.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAGjE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAoID;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,GAAG,gBAAgB,CAsB1F;AAED,uHAAuH;AACvH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,GAAG,cAAc,CAE5F"}

package/dist/parse/parse-cursor-rule.js

@@ -1,41 +1,113 @@
+import { FrontmatterScalarMode, parseFrontmatter, parseInlineScalar, splitFrontmatter, } from '@shrkcrft/core';
 import { KnowledgePriority, KnowledgeType } from '@shrkcrft/knowledge';
 import { keywordTags, slugify } from "./slugify.js";
-function parseFrontmatter(raw) {
-    // Normalize CRLF/CR first: otherwise a trailing `\r` breaks the `\n---`
-    // separator offset math AND the `key: (.*)$` regex (`$` won't span `\r`),
-    // dropping description/globs/tags on a Windows-authored .mdc file.
-    const text = raw.replace(/\r\n?/g, '\n');
-    if (!text.startsWith('---'))
-        return { fm: {}, body: text };
-    const end = text.indexOf('\n---', 3);
-    if (end < 0)
-        return { fm: {}, body: text };
-    const block = text.slice(3, end).trim();
-    const body = text.slice(end + 4).replace(/^\n+/, '');
-    const fm = {};
-    for (const line of block.split('\n')) {
-        const m = /^([A-Za-z][\w-]*)\s*:\s*(.*)$/.exec(line);
-        if (!m)
+/** The keys the importer reads as lists — `description` / `priority` are one value each. */
+const MDC_LIST_KEYS = Object.freeze(['globs', 'tags']);
+/**
+ * `.mdc` values are text by contract — read verbatim (no YAML typing, no
+ * ` # comment` strip). Only `globs` / `tags` read an inline `[…]` as a list
+ * (`listKeys`, round 15 closing A1): `description: [WIP]` is the title `[WIP]`,
+ * as the old splitter read it (it was ignored as "a list").
+ */
+const MDC_FRONTMATTER = Object.freeze({
+    scalars: FrontmatterScalarMode.Text,
+    listKeys: MDC_LIST_KEYS,
+});
+/** The frontmatter keys the importer reads; every other key (`alwaysApply`, a tool's `metadata:`) is skipped unparsed. */
+const MDC_KEYS = Object.freeze(['description', 'globs', 'tags', 'priority']);
+function shapeOf(value) {
+    if (!Array.isArray(value))
+        return 'a map';
+    return value.some((v) => v !== null && typeof v === 'object') ? 'a list of maps' : 'a list';
+}
+/**
+ * A comma-separated value (`globs: src/**\/*.ts, test/**`) read through THE
+ * parser's inline-list grammar: quote-aware and bracket/brace-aware, so
+ * `"a, b"` and `*.{ts,tsx}` each stay one item.
+ */
+function listFromText(value) {
+    const r = parseInlineScalar(`[${value}]`, 0, MDC_FRONTMATTER);
+    if (!r.ok || !Array.isArray(r.value))
+        return undefined;
+    return r.value.filter((v) => v !== null && String(v).length > 0).map((v) => String(v));
+}
+function readCursorFrontmatter(raw) {
+    const split = splitFrontmatter(raw);
+    const problems = [];
+    if (split.unterminated) {
+        problems.push('frontmatter: an opening --- line has no closing --- line — the whole file is read as the body');
+    }
+    if (split.frontmatter === undefined)
+        return { fm: {}, body: split.body, problems };
+    const at = { ...MDC_FRONTMATTER, lineOffset: split.lineOffset };
+    // The top-level structure alone (no key read): a line that names no key
+    // means the block is not frontmatter THE parser can read at all.
+    const structure = parseFrontmatter(split.frontmatter, { ...at, keys: [] });
+    if (!structure.ok) {
+        problems.push(`frontmatter not read (${structure.error.message}) — description, globs, tags and priority are ignored; the title comes from the body`);
+        return { fm: {}, body: split.body, problems };
+    }
+    // Each key the importer reads, parsed on its own — every other block is
+    // skipped unparsed (`alwaysApply`, a tool's `metadata:`): YAML the parser
+    // does not speak under one key costs that key alone, never its siblings (the
+    // old splitter read every other line regardless).
+    const fields = {};
+    for (const key of MDC_KEYS) {
+        const read = parseFrontmatter(split.frontmatter, { ...at, keys: [key] });
+        if (!read.ok) {
+            problems.push(`${key}: not read (${read.error.message}) — ignored${key === 'description' ? '; the title comes from the body' : ''}`);
             continue;
-        const key = m[1];
-        let value = m[2].trim();
-        // Strip wrapping quotes / brackets.
-        if (value.startsWith('"') && value.endsWith('"'))
-            value = value.slice(1, -1);
-        if (value.startsWith("'") && value.endsWith("'"))
-            value = value.slice(1, -1);
-        if (key === 'tags' || key === 'globs') {
-            const list = value.replace(/^\[|\]$/g, '').split(',').map((s) => s.trim().replace(/^['"]|['"]$/g, ''));
-            fm[key] = list.filter(Boolean);
         }
-        else if (key === 'alwaysApply') {
-            fm.alwaysApply = value.toLowerCase() === 'true';
+        const value = read.value[key];
+        if (value !== undefined)
+            fields[key] = value;
+    }
+    const text = (key) => {
+        const v = fields[key];
+        if (v === undefined || v === null)
+            return undefined;
+        if (typeof v === 'string')
+            return v.trim().length > 0 ? v : undefined;
+        if (typeof v === 'number' || typeof v === 'boolean')
+            return String(v);
+        problems.push(`${key}: must be a single value (got ${shapeOf(v)}) — ignored`);
+        return undefined;
+    };
+    const list = (key) => {
+        const v = fields[key];
+        if (v === undefined || v === null)
+            return undefined;
+        if (typeof v === 'string') {
+            const items = listFromText(v);
+            if (items === undefined) {
+                problems.push(`${key}: "${v}" is not a comma-separated list — ignored`);
+                return undefined;
+            }
+            return [...items];
         }
-        else {
-            fm[key] = value;
+        if (typeof v === 'number' || typeof v === 'boolean')
+            return [String(v)];
+        const items = Array.isArray(v) ? v : undefined;
+        if (items === undefined || items.some((x) => x !== null && typeof x === 'object')) {
+            problems.push(`${key}: must be a list of plain values or a comma-separated string (got ${shapeOf(v)}) — ignored`);
+            return undefined;
         }
-    }
-    return { fm, body };
+        return items.filter((x) => x !== null && String(x).length > 0).map((x) => String(x));
+    };
+    const fm = {};
+    const description = text('description');
+    if (description !== undefined)
+        fm.description = description;
+    const tags = list('tags');
+    if (tags !== undefined)
+        fm.tags = tags;
+    const globs = list('globs');
+    if (globs !== undefined)
+        fm.globs = globs;
+    const priority = text('priority');
+    if (priority !== undefined)
+        fm.priority = priority;
+    return { fm, body: split.body, problems };
 }
 function priorityFromString(input) {
     switch ((input ?? '').toLowerCase()) {
@@ -49,8 +121,14 @@ function priorityFromString(input) {
             return KnowledgePriority.Medium;
     }
 }
-export function parseCursorRuleFile(raw, options) {
-    const { fm, body } = parseFrontmatter(raw);
+/**
+ * Parse one `.mdc` rule, with every reason (part of) its frontmatter was not
+ * read — the importer surfaces each as a warning (round 15 follow-up, F6: the
+ * old line splitter skipped an unreadable line, a block list or a whole BOM /
+ * `--- ` file without a word).
+ */
+export function parseCursorRule(raw, options) {
+    const { fm, body, problems } = readCursorFrontmatter(raw);
     const title = fm.description ?? body.split('\n').find((l) => l.trim().length > 0) ?? options.idPrefix;
     const baseSlug = slugify(title) || slugify(options.idPrefix);
     const tags = [
@@ -60,7 +138,7 @@ export function parseCursorRuleFile(raw, options) {
             ...keywordTags(title),
         ]),
     ];
-    return {
+    const entry = {
         id: `${options.idPrefix}.${baseSlug}`,
         title: title.slice(0, 100),
         type: KnowledgeType.Rule,
@@ -70,4 +148,9 @@ export function parseCursorRuleFile(raw, options) {
         content: body.trim(),
         origin: options.origin,
     };
+    return { entry, problems };
+}
+/** {@link parseCursorRule}'s entry alone (the frontmatter problems are dropped — `importCursorRules` reports them). */
+export function parseCursorRuleFile(raw, options) {
+    return parseCursorRule(raw, options).entry;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shrkcrft/importer",
-  "version": "0.1.0-alpha.31",
+  "version": "0.1.0-alpha.32",
   "description": "SharkCraft importer: parse AGENTS.md / CLAUDE.md / .cursor/rules into structured knowledge entries.",
   "license": "MIT",
   "author": "SharkCraft contributors",
@@ -44,8 +44,8 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@shrkcrft/core": "^0.1.0-alpha.31",
-    "@shrkcrft/knowledge": "^0.1.0-alpha.31"
+    "@shrkcrft/core": "^0.1.0-alpha.32",
+    "@shrkcrft/knowledge": "^0.1.0-alpha.32"
   },
   "publishConfig": {
     "access": "public"