@shrkcrft/importer 0.1.0-alpha.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SharkCraft contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# @shrkcrft/importer
+
+SharkCraft importer: parse AGENTS.md / CLAUDE.md / .cursor/rules into structured knowledge entries.
+
+Part of [SharkCraft](https://github.com/shrkcrft/sharkcraft) — a deterministic, local-first toolkit that gives AI coding agents durable project context. See the main repo for documentation, examples, and the `shrk` CLI.
+
+## Install
+
+```bash
+bun add @shrkcrft/importer
+```
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/api/import-agents-md.d.ts

@@ -0,0 +1,15 @@
+import type { IImportResult } from '../model/import-result.js';
+export interface IImportAgentsMdOptions {
+    /** Absolute or relative path to AGENTS.md. */
+    filePath: string;
+    /** Project root (used to relativize origin paths in the result). */
+    projectRoot?: string;
+    /** Override the entry id prefix. Defaults to "agents". */
+    idPrefix?: string;
+    /** Extra tags appended to every produced entry. */
+    extraTags?: readonly string[];
+    /** Scope tokens appended to every produced entry. */
+    scope?: readonly string[];
+}
+export declare function importAgentsMd(options: IImportAgentsMdOptions): IImportResult;
+//# sourceMappingURL=import-agents-md.d.ts.map

package/dist/api/import-agents-md.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-agents-md.d.ts","sourceRoot":"","sources":["../../src/api/import-agents-md.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG/D,MAAM,WAAW,sBAAsB;IACrC,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0DAA0D;IAC1D,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;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,sBAAsB,GAAG,aAAa,CA+B7E"}

package/dist/api/import-agents-md.js

@@ -0,0 +1,35 @@
+import { existsSync, readFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { parseMarkdownRules } from "../parse/parse-markdown-rules.js";
+export function importAgentsMd(options) {
+    const root = options.projectRoot ?? process.cwd();
+    const file = nodePath.isAbsolute(options.filePath)
+        ? options.filePath
+        : nodePath.resolve(root, options.filePath);
+    if (!existsSync(file)) {
+        return {
+            format: 'agents-md',
+            sourceFiles: [],
+            entries: [],
+            warnings: [{ origin: options.filePath, message: 'File does not exist.' }],
+        };
+    }
+    const raw = readFileSync(file, 'utf8');
+    const origin = nodePath.relative(root, file) || nodePath.basename(file);
+    const entries = parseMarkdownRules(raw, {
+        origin,
+        idPrefix: options.idPrefix ?? 'agents',
+    }).map((e) => ({
+        ...e,
+        tags: [...new Set([...e.tags, ...(options.extraTags ?? []), ...(options.scope ?? [])])],
+    }));
+    const warnings = entries.length === 0
+        ? [{ origin, message: 'No bullet rules or headed paragraphs found.' }]
+        : [];
+    return {
+        format: 'agents-md',
+        sourceFiles: [origin],
+        entries,
+        warnings,
+    };
+}

package/dist/api/import-claude-md.d.ts

@@ -0,0 +1,11 @@
+import type { IImportResult } from '../model/import-result.js';
+export interface IImportClaudeMdOptions {
+    /** Path to CLAUDE.md (absolute or relative to projectRoot). */
+    filePath: string;
+    projectRoot?: string;
+    idPrefix?: string;
+    extraTags?: readonly string[];
+    scope?: readonly string[];
+}
+export declare function importClaudeMd(options: IImportClaudeMdOptions): IImportResult;
+//# sourceMappingURL=import-claude-md.d.ts.map

package/dist/api/import-claude-md.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-claude-md.d.ts","sourceRoot":"","sources":["../../src/api/import-claude-md.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG/D,MAAM,WAAW,sBAAsB;IACrC,+DAA+D;IAC/D,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,sBAAsB,GAAG,aAAa,CA8B7E"}

package/dist/api/import-claude-md.js

@@ -0,0 +1,34 @@
+import { existsSync, readFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { parseMarkdownRules } from "../parse/parse-markdown-rules.js";
+export function importClaudeMd(options) {
+    const root = options.projectRoot ?? process.cwd();
+    const file = nodePath.isAbsolute(options.filePath)
+        ? options.filePath
+        : nodePath.resolve(root, options.filePath);
+    if (!existsSync(file)) {
+        return {
+            format: 'claude-md',
+            sourceFiles: [],
+            entries: [],
+            warnings: [{ origin: options.filePath, message: 'File does not exist.' }],
+        };
+    }
+    const raw = readFileSync(file, 'utf8');
+    const origin = nodePath.relative(root, file) || nodePath.basename(file);
+    const entries = parseMarkdownRules(raw, {
+        origin,
+        idPrefix: options.idPrefix ?? 'claude',
+    }).map((e) => ({
+        ...e,
+        tags: [...new Set([...e.tags, ...(options.extraTags ?? []), ...(options.scope ?? [])])],
+    }));
+    return {
+        format: 'claude-md',
+        sourceFiles: [origin],
+        entries,
+        warnings: entries.length === 0
+            ? [{ origin, message: 'No bullet rules or headed paragraphs found.' }]
+            : [],
+    };
+}

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

@@ -0,0 +1,14 @@
+import type { IImportResult } from '../model/import-result.js';
+export interface IImportCursorRulesOptions {
+    /** Path to .cursor/rules directory OR a single .mdc file. */
+    filePath: string;
+    projectRoot?: string;
+    /** Override id prefix (per-file slug still appended). Defaults to "cursor". */
+    idPrefix?: string;
+    /** Extra tags appended to every produced entry. */
+    extraTags?: readonly string[];
+    /** Scope tokens appended to every produced entry. */
+    scope?: readonly string[];
+}
+export declare function importCursorRules(options: IImportCursorRulesOptions): IImportResult;
+//# sourceMappingURL=import-cursor-rules.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,88 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { parseCursorRuleFile } from "../parse/parse-cursor-rule.js";
+import { slugify } from "../parse/slugify.js";
+function walkMdcFiles(start) {
+    const out = [];
+    const stack = [start];
+    while (stack.length) {
+        const cur = stack.pop();
+        let stat;
+        try {
+            stat = statSync(cur);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isFile()) {
+            if (cur.endsWith('.mdc') || cur.endsWith('.md'))
+                out.push(cur);
+            continue;
+        }
+        if (!stat.isDirectory())
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(cur);
+        }
+        catch {
+            continue;
+        }
+        for (const name of entries)
+            stack.push(nodePath.join(cur, name));
+    }
+    return out.sort();
+}
+export function importCursorRules(options) {
+    const root = options.projectRoot ?? process.cwd();
+    const target = nodePath.isAbsolute(options.filePath)
+        ? options.filePath
+        : nodePath.resolve(root, options.filePath);
+    if (!existsSync(target)) {
+        return {
+            format: 'cursor-rules',
+            sourceFiles: [],
+            entries: [],
+            warnings: [{ origin: options.filePath, message: 'File or directory does not exist.' }],
+        };
+    }
+    const files = walkMdcFiles(target);
+    const entries = [];
+    const warnings = [];
+    const seenIds = new Set();
+    const basePrefix = options.idPrefix ?? 'cursor';
+    for (const file of files) {
+        const raw = readFileSync(file, 'utf8');
+        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 });
+        let id = entry.id;
+        let counter = 2;
+        while (seenIds.has(id)) {
+            id = `${entry.id}-${counter}`;
+            counter += 1;
+        }
+        seenIds.add(id);
+        const tags = [
+            ...new Set([
+                ...entry.tags,
+                ...(options.extraTags ?? []),
+                ...(options.scope ?? []),
+            ]),
+        ];
+        entries.push({ ...entry, id, tags });
+    }
+    if (files.length === 0) {
+        warnings.push({
+            origin: nodePath.relative(root, target) || target,
+            message: 'No .mdc / .md files found under target.',
+        });
+    }
+    return {
+        format: 'cursor-rules',
+        sourceFiles: files.map((f) => nodePath.relative(root, f) || f),
+        entries,
+        warnings,
+    };
+}

package/dist/emit/emit-knowledge-ts.d.ts

@@ -0,0 +1,17 @@
+import type { IImportedEntry } from '../model/imported-entry.js';
+/**
+ * Render imported entries as a TypeScript module that defines a knowledge
+ * base. The output is a self-contained, deterministic source file callers can
+ * write into their `sharkcraft/` folder.
+ *
+ * The emitter avoids exotic escaping: it serializes each entry through
+ * JSON.stringify with re-indentation and a final `as const` cast.
+ */
+export interface IEmitOptions {
+    /** Header comment explaining where the file came from. */
+    sourceLabel: string;
+    /** Variable name to export (default: importedKnowledge). */
+    exportName?: string;
+}
+export declare function emitKnowledgeTs(entries: readonly IImportedEntry[], opts: IEmitOptions): string;
+//# sourceMappingURL=emit-knowledge-ts.d.ts.map

package/dist/emit/emit-knowledge-ts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-knowledge-ts.d.ts","sourceRoot":"","sources":["../../src/emit/emit-knowledge-ts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAEjE;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,0DAA0D;IAC1D,WAAW,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,EAAE,IAAI,EAAE,YAAY,GAAG,MAAM,CAc9F"}

package/dist/emit/emit-knowledge-ts.js

@@ -0,0 +1,66 @@
+export function emitKnowledgeTs(entries, opts) {
+    const exportName = opts.exportName ?? 'importedKnowledge';
+    const items = entries.map(serializeEntry).join(',\n');
+    return [
+        '// Auto-generated by `shrk import`.',
+        `// Source: ${opts.sourceLabel}`,
+        '// Review every entry — the importer is best-effort and types/priorities are inferred.',
+        "import { defineKnowledgeEntry, KnowledgePriority, KnowledgeType } from '@shrkcrft/knowledge';",
+        '',
+        `export const ${exportName} = [`,
+        items,
+        '];',
+        '',
+    ].join('\n');
+}
+function escapeBackticks(s) {
+    return s.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+}
+function serializeEntry(entry) {
+    const lines = [];
+    lines.push('  defineKnowledgeEntry({');
+    lines.push(`    id: ${JSON.stringify(entry.id)},`);
+    lines.push(`    title: ${JSON.stringify(entry.title)},`);
+    lines.push(`    type: KnowledgeType.${capitalize(entry.type)},`);
+    lines.push(`    priority: KnowledgePriority.${capitalize(entry.priority)},`);
+    if (entry.tags.length > 0) {
+        lines.push(`    tags: ${JSON.stringify(entry.tags)},`);
+    }
+    if (entry.section) {
+        lines.push(`    // section: ${JSON.stringify(entry.section)}`);
+    }
+    lines.push('    content: `' + escapeBackticks(entry.content) + '`,');
+    lines.push('  })');
+    return lines.join('\n');
+}
+function capitalize(s) {
+    // KnowledgeType / KnowledgePriority members are PascalCase enum members but
+    // string values are kebab-or-lower; map known values explicitly.
+    const map = {
+        rule: 'Rule',
+        path: 'Path',
+        template: 'Template',
+        architecture: 'Architecture',
+        technical: 'Technical',
+        business: 'Business',
+        command: 'Command',
+        environment: 'Environment',
+        dependency: 'Dependency',
+        feature: 'Feature',
+        task: 'Task',
+        warning: 'Warning',
+        decision: 'Decision',
+        convention: 'Convention',
+        workflow: 'Workflow',
+        testing: 'Testing',
+        security: 'Security',
+        deployment: 'Deployment',
+        integration: 'Integration',
+        custom: 'Custom',
+        critical: 'Critical',
+        high: 'High',
+        medium: 'Medium',
+        low: 'Low',
+    };
+    return map[s] ?? s.charAt(0).toUpperCase() + s.slice(1);
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './model/import-format.js';
+export * from './model/import-result.js';
+export * from './model/imported-entry.js';
+export * from './parse/parse-markdown-rules.js';
+export * from './parse/parse-cursor-rule.js';
+export * from './parse/slugify.js';
+export * from './api/import-agents-md.js';
+export * from './api/import-claude-md.js';
+export * from './api/import-cursor-rules.js';
+export * from './emit/emit-knowledge-ts.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+export * from "./model/import-format.js";
+export * from "./model/import-result.js";
+export * from "./model/imported-entry.js";
+export * from "./parse/parse-markdown-rules.js";
+export * from "./parse/parse-cursor-rule.js";
+export * from "./parse/slugify.js";
+export * from "./api/import-agents-md.js";
+export * from "./api/import-claude-md.js";
+export * from "./api/import-cursor-rules.js";
+export * from "./emit/emit-knowledge-ts.js";

package/dist/model/import-format.d.ts

@@ -0,0 +1,7 @@
+export declare enum ImportFormat {
+    AgentsMd = "agents-md",
+    ClaudeMd = "claude-md",
+    CursorRules = "cursor-rules"
+}
+export declare function parseImportFormat(input: string): ImportFormat | undefined;
+//# sourceMappingURL=import-format.d.ts.map

package/dist/model/import-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-format.d.ts","sourceRoot":"","sources":["../../src/model/import-format.ts"],"names":[],"mappings":"AAAA,oBAAY,YAAY;IACtB,QAAQ,cAAc;IACtB,QAAQ,cAAc;IACtB,WAAW,iBAAiB;CAC7B;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAczE"}

package/dist/model/import-format.js

@@ -0,0 +1,21 @@
+export var ImportFormat;
+(function (ImportFormat) {
+    ImportFormat["AgentsMd"] = "agents-md";
+    ImportFormat["ClaudeMd"] = "claude-md";
+    ImportFormat["CursorRules"] = "cursor-rules";
+})(ImportFormat || (ImportFormat = {}));
+export function parseImportFormat(input) {
+    switch (input) {
+        case 'agents-md':
+        case 'AGENTS.md':
+            return ImportFormat.AgentsMd;
+        case 'claude-md':
+        case 'CLAUDE.md':
+            return ImportFormat.ClaudeMd;
+        case 'cursor-rules':
+        case 'cursor':
+            return ImportFormat.CursorRules;
+        default:
+            return undefined;
+    }
+}

package/dist/model/import-result.d.ts

@@ -0,0 +1,16 @@
+import type { IImportedEntry } from './imported-entry.js';
+export interface IImportWarning {
+    origin: string;
+    message: string;
+}
+export interface IImportResult {
+    /** Source format that produced the entries. */
+    format: string;
+    /** Files that were read. */
+    sourceFiles: string[];
+    /** Parsed entries (deduped by id). */
+    entries: IImportedEntry[];
+    /** Non-fatal issues (missing headings, ambiguous priority, …). */
+    warnings: IImportWarning[];
+}
+//# sourceMappingURL=import-result.d.ts.map

package/dist/model/import-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-result.d.ts","sourceRoot":"","sources":["../../src/model/import-result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,4BAA4B;IAC5B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,sCAAsC;IACtC,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,kEAAkE;IAClE,QAAQ,EAAE,cAAc,EAAE,CAAC;CAC5B"}

package/dist/model/import-result.js

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

package/dist/model/imported-entry.d.ts

@@ -0,0 +1,27 @@
+import { KnowledgePriority, KnowledgeType } from '@shrkcrft/knowledge';
+/**
+ * A single rule / fact parsed from an external agent file. Looser than
+ * {@link IKnowledgeEntry} — fields are best-effort and the emitter fills the
+ * gaps with conservative defaults.
+ */
+export interface IImportedEntry {
+    /** Stable id derived from the source heading + slug. */
+    id: string;
+    /** First sentence / first line of the rule body — used as the entry title. */
+    title: string;
+    /** Best-guess knowledge type from the source. Defaults to rule. */
+    type: KnowledgeType;
+    /** Best-guess priority. Defaults to medium. */
+    priority: KnowledgePriority;
+    /** Heading the entry was found under (e.g. "Coding standards"). */
+    section?: string;
+    /** Tags inferred from heading or the entry body. */
+    tags: string[];
+    /** Full body content. Markdown is preserved as-is. */
+    content: string;
+    /** Source file (relative to the import root). */
+    origin: string;
+    /** Free-form notes the importer wants to surface (e.g. "rule had no header"). */
+    importerNotes?: string[];
+}
+//# sourceMappingURL=imported-entry.d.ts.map

package/dist/model/imported-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imported-entry.d.ts","sourceRoot":"","sources":["../../src/model/imported-entry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEvE;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,wDAAwD;IACxD,EAAE,EAAE,MAAM,CAAC;IACX,8EAA8E;IAC9E,KAAK,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,IAAI,EAAE,aAAa,CAAC;IACpB,+CAA+C;IAC/C,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,mEAAmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oDAAoD;IACpD,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,iFAAiF;IACjF,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B"}

package/dist/model/imported-entry.js

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

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

@@ -0,0 +1,15 @@
+import type { IImportedEntry } from '../model/imported-entry.js';
+/**
+ * Parse a single .cursor/rules/*.mdc file. MDC format = YAML frontmatter
+ * (between `---` markers) + markdown body. We extract:
+ *   - `description` → entry title
+ *   - `globs` / `tags` → tags
+ *   - `priority` (if present) → KnowledgePriority
+ *   - the body → content
+ */
+export interface ICursorRuleOptions {
+    origin: string;
+    idPrefix: string;
+}
+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

@@ -0,0 +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;AAoDD,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,kBAAkB,GAC1B,cAAc,CAqBhB"}

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

@@ -0,0 +1,69 @@
+import { KnowledgePriority, KnowledgeType } from '@shrkcrft/knowledge';
+import { keywordTags, slugify } from "./slugify.js";
+function parseFrontmatter(raw) {
+    if (!raw.startsWith('---'))
+        return { fm: {}, body: raw };
+    const end = raw.indexOf('\n---', 3);
+    if (end < 0)
+        return { fm: {}, body: raw };
+    const block = raw.slice(3, end).trim();
+    const body = raw.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)
+            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';
+        }
+        else {
+            fm[key] = value;
+        }
+    }
+    return { fm, body };
+}
+function priorityFromString(input) {
+    switch ((input ?? '').toLowerCase()) {
+        case 'critical':
+            return KnowledgePriority.Critical;
+        case 'high':
+            return KnowledgePriority.High;
+        case 'low':
+            return KnowledgePriority.Low;
+        default:
+            return KnowledgePriority.Medium;
+    }
+}
+export function parseCursorRuleFile(raw, options) {
+    const { fm, body } = parseFrontmatter(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 = [
+        ...new Set([
+            ...(fm.tags ?? []),
+            ...(fm.globs ?? []).map((g) => g.replace(/[*?]/g, '')).map((g) => slugify(g)).filter(Boolean),
+            ...keywordTags(title),
+        ]),
+    ];
+    return {
+        id: `${options.idPrefix}.${baseSlug}`,
+        title: title.slice(0, 100),
+        type: KnowledgeType.Rule,
+        priority: priorityFromString(fm.priority),
+        section: 'cursor-rules',
+        tags,
+        content: body.trim(),
+        origin: options.origin,
+    };
+}

package/dist/parse/parse-markdown-rules.d.ts

@@ -0,0 +1,18 @@
+import type { IImportedEntry } from '../model/imported-entry.js';
+/**
+ * Generic markdown-rules parser. Walks H1/H2/H3 sections; treats:
+ *   - top-level bullets under a heading as separate rules
+ *   - non-bullet paragraphs as a single rule with the heading as title
+ *
+ * Conservatively maps headings to knowledge types: "path"/"location" →
+ * PathConvention, "architecture"/"layer" → Architecture, "task"/"todo" → Task,
+ * everything else → Rule.
+ */
+export interface IMarkdownParseOptions {
+    /** Origin tag stamped onto every produced entry. */
+    origin: string;
+    /** Prefix for derived ids (e.g. "claude" → "claude.rule.<slug>"). */
+    idPrefix: string;
+}
+export declare function parseMarkdownRules(raw: string, options: IMarkdownParseOptions): IImportedEntry[];
+//# sourceMappingURL=parse-markdown-rules.d.ts.map

package/dist/parse/parse-markdown-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-markdown-rules.d.ts","sourceRoot":"","sources":["../../src/parse/parse-markdown-rules.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAGjE;;;;;;;;GAQG;AACH,MAAM,WAAW,qBAAqB;IACpC,oDAAoD;IACpD,MAAM,EAAE,MAAM,CAAC;IACf,qEAAqE;IACrE,QAAQ,EAAE,MAAM,CAAC;CAClB;AAkED,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,qBAAqB,GAC7B,cAAc,EAAE,CAiElB"}

package/dist/parse/parse-markdown-rules.js

@@ -0,0 +1,133 @@
+import { KnowledgePriority, KnowledgeType } from '@shrkcrft/knowledge';
+import { keywordTags, slugify } from "./slugify.js";
+const PRIORITY_PATTERNS = [
+    { pattern: /\b(critical|never|must not|forbidden|do not)\b/i, value: KnowledgePriority.Critical },
+    { pattern: /\b(must|required|always|do)\b/i, value: KnowledgePriority.High },
+    { pattern: /\b(should|prefer)\b/i, value: KnowledgePriority.Medium },
+    { pattern: /\b(may|optional|nice to have)\b/i, value: KnowledgePriority.Low },
+];
+function inferPriority(text) {
+    for (const { pattern, value } of PRIORITY_PATTERNS) {
+        if (pattern.test(text))
+            return value;
+    }
+    return KnowledgePriority.Medium;
+}
+function inferType(heading) {
+    const h = heading.toLowerCase();
+    if (h.includes('path') || h.includes('layout') || h.includes('location')) {
+        return KnowledgeType.Path;
+    }
+    if (h.includes('architecture') || h.includes('layer'))
+        return KnowledgeType.Architecture;
+    if (h.includes('task') || h.includes('todo') || h.includes('roadmap'))
+        return KnowledgeType.Task;
+    if (h.includes('decision') || h.includes('adr'))
+        return KnowledgeType.Decision;
+    if (h.includes('command'))
+        return KnowledgeType.Command;
+    if (h.includes('test'))
+        return KnowledgeType.Testing;
+    if (h.includes('security'))
+        return KnowledgeType.Security;
+    if (h.includes('deploy'))
+        return KnowledgeType.Deployment;
+    if (h.includes('convention'))
+        return KnowledgeType.Convention;
+    if (h.includes('workflow'))
+        return KnowledgeType.Workflow;
+    return KnowledgeType.Rule;
+}
+function extractTitle(text) {
+    const stripped = text.replace(/\*\*|__|`/g, '').trim();
+    const firstLine = stripped.split('\n')[0] ?? '';
+    // First sentence up to 80 chars.
+    const sentenceEnd = firstLine.search(/[.!?](\s|$)/);
+    if (sentenceEnd > 0 && sentenceEnd < 100) {
+        return firstLine.slice(0, sentenceEnd).trim();
+    }
+    return firstLine.slice(0, 80).trim();
+}
+function bulletsFromBlock(block) {
+    const lines = block.split('\n');
+    const out = [];
+    let current = '';
+    for (const line of lines) {
+        if (/^[-*]\s+/.test(line)) {
+            if (current)
+                out.push(current.trim());
+            current = line.replace(/^[-*]\s+/, '');
+        }
+        else if (current && (/^\s{2,}/.test(line) || line.trim() === '')) {
+            current += '\n' + line;
+        }
+    }
+    if (current)
+        out.push(current.trim());
+    return out;
+}
+export function parseMarkdownRules(raw, options) {
+    const entries = [];
+    const lines = raw.split('\n');
+    const sections = [];
+    let current = null;
+    let paragraph = [];
+    const flushPara = () => {
+        if (paragraph.length === 0)
+            return;
+        const block = paragraph.join('\n').trim();
+        if (block.length > 0 && current) {
+            current.paragraphs.push(block);
+        }
+        paragraph = [];
+    };
+    for (const line of lines) {
+        const headingMatch = /^(#{1,6})\s+(.*)$/.exec(line);
+        if (headingMatch) {
+            flushPara();
+            if (current)
+                sections.push(current);
+            current = { heading: headingMatch[2].trim(), level: headingMatch[1].length, paragraphs: [] };
+            continue;
+        }
+        paragraph.push(line);
+    }
+    flushPara();
+    if (current)
+        sections.push(current);
+    const seen = new Set();
+    for (const section of sections) {
+        const type = inferType(section.heading);
+        const tagsFromHeading = keywordTags(section.heading);
+        for (const block of section.paragraphs) {
+            const bullets = bulletsFromBlock(block);
+            const units = bullets.length > 0 ? bullets : [block];
+            for (const unit of units) {
+                const title = extractTitle(unit);
+                if (!title)
+                    continue;
+                const slugBase = slugify(`${section.heading}-${title}`) || slugify(title);
+                let id = `${options.idPrefix}.${slugBase}`;
+                let counter = 2;
+                while (seen.has(id)) {
+                    id = `${options.idPrefix}.${slugBase}-${counter}`;
+                    counter += 1;
+                }
+                seen.add(id);
+                const priority = inferPriority(unit);
+                const tags = [...new Set([...tagsFromHeading, ...keywordTags(title)])];
+                entries.push({
+                    id,
+                    title,
+                    type,
+                    priority,
+                    section: section.heading,
+                    tags,
+                    content: unit.trim(),
+                    origin: options.origin,
+                });
+            }
+        }
+    }
+    return entries;
+}

package/dist/parse/slugify.d.ts

@@ -0,0 +1,4 @@
+export declare function slugify(input: string): string;
+/** Pull 2–4 keyword-like tokens from a string for tag inference. */
+export declare function keywordTags(input: string): string[];
+//# sourceMappingURL=slugify.d.ts.map

package/dist/parse/slugify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slugify.d.ts","sourceRoot":"","sources":["../../src/parse/slugify.ts"],"names":[],"mappings":"AAAA,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAM7C;AAmCD,oEAAoE;AACpE,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAWnD"}

package/dist/parse/slugify.js

@@ -0,0 +1,54 @@
+export function slugify(input) {
+    return input
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 80);
+}
+const STOP_WORDS = new Set([
+    'a',
+    'an',
+    'the',
+    'and',
+    'or',
+    'but',
+    'of',
+    'in',
+    'on',
+    'to',
+    'for',
+    'with',
+    'is',
+    'are',
+    'be',
+    'as',
+    'at',
+    'by',
+    'from',
+    'this',
+    'that',
+    'should',
+    'must',
+    'do',
+    'not',
+    'never',
+    'always',
+    'use',
+    'when',
+    'if',
+]);
+/** Pull 2–4 keyword-like tokens from a string for tag inference. */
+export function keywordTags(input) {
+    const tokens = input
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((t) => t.length >= 3 && !STOP_WORDS.has(t));
+    const out = [];
+    for (const t of tokens) {
+        if (!out.includes(t))
+            out.push(t);
+        if (out.length === 4)
+            break;
+    }
+    return out;
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@shrkcrft/importer",
+  "version": "0.1.0-alpha.2",
+  "description": "SharkCraft importer: parse AGENTS.md / CLAUDE.md / .cursor/rules into structured knowledge entries.",
+  "license": "MIT",
+  "author": "SharkCraft contributors",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shrkcrft/sharkcraft.git",
+    "directory": "packages/importer"
+  },
+  "homepage": "https://github.com/shrkcrft/sharkcraft",
+  "bugs": {
+    "url": "https://github.com/shrkcrft/sharkcraft/issues"
+  },
+  "keywords": [
+    "sharkcraft",
+    "importer",
+    "agents-md",
+    "claude-md",
+    "cursor"
+  ],
+  "engines": {
+    "bun": ">=1.1.0",
+    "node": ">=18"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@shrkcrft/core": "^0.1.0-alpha.2",
+    "@shrkcrft/knowledge": "^0.1.0-alpha.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}