@shrkcrft/importer 0.1.0-alpha.6 → 0.1.0-alpha.8

package/dist/emit/synthesize-populated.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Convert imported `IImportedEntry[]` into populated `sharkcraft/*.ts`
+ * file contents — the engine behind `shrk import <format> --populate`.
+ *
+ * Why this exists separately from `emitKnowledgeTs`:
+ *
+ *   - `emitKnowledgeTs` produces ONE draft TS file under
+ *     `sharkcraft/imports/<format>-import.draft.ts` — advisory only,
+ *     user adopts by hand.
+ *   - `synthesizePopulated` distributes entries across `rules.ts` /
+ *     `paths.ts` / `knowledge.ts` by type AND emits a confidence
+ *     report (.imported-report.md). The user gets a working repo
+ *     from a single command, not a TODO list.
+ *
+ * Mirror of `synthesize-from-onboarding.ts` in `@shrkcrft/inspector`:
+ * same shape, same honesty contract, same self-contained output (no
+ * `@shrkcrft/*` imports in generated files).
+ */
+import type { IImportedEntry } from '../model/imported-entry.js';
+export interface IPopulatedFile {
+    /** Path relative to sharkcraft/. */
+    path: string;
+    content: string;
+    /** Which kind of file this is — drives report naming. */
+    kind: 'config' | 'rules' | 'paths' | 'knowledge' | 'report-md' | 'report-json';
+}
+export interface IImportConfidenceLine {
+    kind: 'rule' | 'path' | 'knowledge' | 'template';
+    id: string;
+    title: string;
+    /** What signal made us pick this confidence tier. */
+    reason: string;
+    /** The source file the entry came from. */
+    origin: string;
+}
+export interface IImportConfidenceReport {
+    /** Entries adopted directly (high confidence). */
+    adoptedHigh: readonly IImportConfidenceLine[];
+    /** Entries adopted with a `// TODO: review` marker (medium). */
+    adoptedMedium: readonly IImportConfidenceLine[];
+    /** Entries dropped — body too thin / type not safe to auto-populate. */
+    dropped: readonly IImportConfidenceLine[];
+    /** Reminder: things shrk import doesn't try to recover from markdown. */
+    notInferable: readonly string[];
+}
+export interface IPopulatedImportResult {
+    files: readonly IPopulatedFile[];
+    report: IImportConfidenceReport;
+}
+export interface ISynthesizePopulatedOptions {
+    /** Project name for the generated sharkcraft.config.ts. */
+    projectName: string;
+    /** Free-form project description (passed through to knowledge.ts overview). */
+    description?: string;
+    /** Source label (e.g. "CLAUDE.md", ".cursor/rules") for the report header. */
+    sourceLabel: string;
+    /** When set, only entries whose tags intersect this list are populated. */
+    filterTags?: readonly string[];
+}
+/**
+ * Convert a parsed `IImportResult` into populated sharkcraft/*.ts
+ * files plus a companion confidence report.
+ *
+ * Pure function — caller writes the bytes. Same shape as
+ * `synthesizeFromOnboarding` in `@shrkcrft/inspector`.
+ */
+export declare function synthesizePopulatedFromImport(entries: readonly IImportedEntry[], options: ISynthesizePopulatedOptions): IPopulatedImportResult;
+//# sourceMappingURL=synthesize-populated.d.ts.map

package/dist/emit/synthesize-populated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synthesize-populated.d.ts","sourceRoot":"","sources":["../../src/emit/synthesize-populated.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAIjE,MAAM,WAAW,cAAc;IAC7B,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,yDAAyD;IACzD,IAAI,EAAE,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,WAAW,GAAG,WAAW,GAAG,aAAa,CAAC;CAChF;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,WAAW,GAAG,UAAU,CAAC;IACjD,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;IACf,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,uBAAuB;IACtC,kDAAkD;IAClD,WAAW,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAC9C,gEAAgE;IAChE,aAAa,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAChD,wEAAwE;IACxE,OAAO,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAC1C,yEAAyE;IACzE,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IACjC,MAAM,EAAE,uBAAuB,CAAC;CACjC;AAED,MAAM,WAAW,2BAA2B;IAC1C,2DAA2D;IAC3D,WAAW,EAAE,MAAM,CAAC;IACpB,+EAA+E;IAC/E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,WAAW,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC;AAgUD;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,OAAO,EAAE,2BAA2B,GACnC,sBAAsB,CAkIxB"}

package/dist/emit/synthesize-populated.js

@@ -0,0 +1,406 @@
+/**
+ * Convert imported `IImportedEntry[]` into populated `sharkcraft/*.ts`
+ * file contents — the engine behind `shrk import <format> --populate`.
+ *
+ * Why this exists separately from `emitKnowledgeTs`:
+ *
+ *   - `emitKnowledgeTs` produces ONE draft TS file under
+ *     `sharkcraft/imports/<format>-import.draft.ts` — advisory only,
+ *     user adopts by hand.
+ *   - `synthesizePopulated` distributes entries across `rules.ts` /
+ *     `paths.ts` / `knowledge.ts` by type AND emits a confidence
+ *     report (.imported-report.md). The user gets a working repo
+ *     from a single command, not a TODO list.
+ *
+ * Mirror of `synthesize-from-onboarding.ts` in `@shrkcrft/inspector`:
+ * same shape, same honesty contract, same self-contained output (no
+ * `@shrkcrft/*` imports in generated files).
+ */
+import { KnowledgePriority, KnowledgeType } from '@shrkcrft/knowledge';
+// ─── Local-mirror preamble (mirrors synthesize-from-onboarding.ts) ──────────
+const KNOWLEDGE_HELPERS = `// Local helpers — keep this file self-contained (no @shrkcrft/* imports).
+// Generated by \`shrk import --populate\`. Edit freely.
+
+const KnowledgePriority = {
+  Critical: 'critical',
+  High: 'high',
+  Medium: 'medium',
+  Low: 'low',
+} as const;
+
+const KnowledgeType = {
+  Rule: 'rule',
+  Path: 'path',
+  Template: 'template',
+  Architecture: 'architecture',
+  Technical: 'technical',
+  Convention: 'convention',
+  Workflow: 'workflow',
+  Warning: 'warning',
+  Security: 'security',
+  Testing: 'testing',
+  Feature: 'feature',
+  Decision: 'decision',
+  Custom: 'custom',
+} as const;
+
+function defineKnowledgeEntry<T>(entry: T): T {
+  return entry;
+}
+`;
+/**
+ * Triage rule:
+ *   - High: priority Critical or High AND non-trivial body (≥40 chars
+ *     beyond title) — the author actually wrote something.
+ *   - Medium: priority Medium, OR non-trivial body but Low priority.
+ *   - Low: priority Low AND thin body. Dropped.
+ *
+ * Title-only entries (no real content) drop regardless of priority —
+ * a one-line title isn't enough to ship as an enforceable rule.
+ */
+function tierOf(entry) {
+    const body = entry.content.trim();
+    const meaningful = body.length > 40 && body !== entry.title.trim();
+    const p = entry.priority;
+    if (!meaningful)
+        return 'low';
+    if (p === KnowledgePriority.Critical || p === KnowledgePriority.High)
+        return 'high';
+    if (p === KnowledgePriority.Medium)
+        return 'medium';
+    return 'low';
+}
+/**
+ * Route an imported entry to a destination file based on its
+ * KnowledgeType. Templates go to "dropped" — they need a runnable
+ * body, which isn't recoverable from markdown.
+ */
+function destinationOf(entry) {
+    switch (entry.type) {
+        case KnowledgeType.Rule:
+            return 'rules';
+        case KnowledgeType.Path:
+            return 'paths';
+        case KnowledgeType.Template:
+            return 'drop';
+        default:
+            // Everything else (Convention / Architecture / Warning / Workflow
+            // / Technical / Security / Testing / Feature / Decision / etc.)
+            // belongs in knowledge.ts.
+            return 'knowledge';
+    }
+}
+// ─── Renderers ──────────────────────────────────────────────────────────────
+function priorityConst(p) {
+    switch (p) {
+        case KnowledgePriority.Critical:
+            return 'KnowledgePriority.Critical';
+        case KnowledgePriority.High:
+            return 'KnowledgePriority.High';
+        case KnowledgePriority.Medium:
+            return 'KnowledgePriority.Medium';
+        default:
+            return 'KnowledgePriority.Low';
+    }
+}
+function typeConst(t) {
+    // Map the (lowercased) KnowledgeType value back to its PascalCase
+    // identifier on the local KnowledgeType const. Anything we don't
+    // recognise falls back to Custom — safe default; doesn't change
+    // loader semantics.
+    switch (t) {
+        case KnowledgeType.Rule: return 'KnowledgeType.Rule';
+        case KnowledgeType.Path: return 'KnowledgeType.Path';
+        case KnowledgeType.Convention: return 'KnowledgeType.Convention';
+        case KnowledgeType.Architecture: return 'KnowledgeType.Architecture';
+        case KnowledgeType.Warning: return 'KnowledgeType.Warning';
+        case KnowledgeType.Workflow: return 'KnowledgeType.Workflow';
+        case KnowledgeType.Technical: return 'KnowledgeType.Technical';
+        case KnowledgeType.Security: return 'KnowledgeType.Security';
+        case KnowledgeType.Testing: return 'KnowledgeType.Testing';
+        case KnowledgeType.Feature: return 'KnowledgeType.Feature';
+        case KnowledgeType.Decision: return 'KnowledgeType.Decision';
+        default: return 'KnowledgeType.Custom';
+    }
+}
+function escapeBackticks(s) {
+    return s.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+}
+function renderEntry(entry, tier, includeTypeField) {
+    const todo = tier === 'medium' ? '  // TODO: review — confidence: medium (imported)\n' : '';
+    const tagsArr = ['imported', ...entry.tags].slice(0, 8);
+    const typeLine = includeTypeField ? `\n    type: ${typeConst(entry.type)},` : '';
+    // Multi-line content goes in a template literal so authoring later
+    // is convenient. Single-line stays in JSON for compactness.
+    const isMultiline = entry.content.includes('\n');
+    const contentLine = isMultiline
+        ? `\n    content: \`${escapeBackticks(entry.content.trim())}\`,`
+        : `\n    content: ${JSON.stringify(entry.content.trim())},`;
+    const sectionComment = entry.section ? `// section: ${entry.section}\n  ` : '';
+    return `  ${todo}  ${sectionComment}defineKnowledgeEntry({
+    id: ${JSON.stringify(entry.id)},
+    title: ${JSON.stringify(entry.title)},${typeLine}
+    priority: ${priorityConst(entry.priority)},
+    tags: ${JSON.stringify(tagsArr)},
+    appliesWhen: ['generate-code', 'review'],${contentLine}
+    metadata: {
+      importedFrom: ${JSON.stringify(entry.origin)},${entry.section ? `\n      sourceSection: ${JSON.stringify(entry.section)},` : ''}
+    },
+  })`;
+}
+// ─── File builders ──────────────────────────────────────────────────────────
+function buildConfigFile(opts) {
+    return (`// Generated by \`shrk import --populate\`. Edit freely; SharkCraft\n` +
+        `// will not regenerate this file. Re-run \`shrk import <format> --populate --force\`\n` +
+        `// to overwrite the populated sharkcraft/*.ts files.\n\n` +
+        `const config = {\n` +
+        `  projectName: ${JSON.stringify(opts.projectName)},\n` +
+        `  description: ${JSON.stringify(opts.description)},\n` +
+        `  pathFiles: ${JSON.stringify(opts.includePaths ? ['paths.ts'] : [])},\n` +
+        `  ruleFiles: ${JSON.stringify(opts.includeRules ? ['rules.ts'] : [])},\n` +
+        `  knowledgeFiles: ${JSON.stringify(['knowledge.ts'])},\n` +
+        `  templateFiles: ${JSON.stringify([])},\n` +
+        `  pipelineFiles: ${JSON.stringify([])},\n` +
+        `  boundaryFiles: ${JSON.stringify([])},\n` +
+        `  docsFiles: ${JSON.stringify([])},\n` +
+        `  defaultMaxTokens: 3500,\n` +
+        `};\n\nexport default config;\n`);
+}
+function buildKnowledgeFile(rendered, projectName, description, sourceLabel) {
+    // Even when knowledge.ts has no imported entries to ship, we still
+    // emit the agent-briefing + safety seed so a fresh repo gets a
+    // sensible baseline.
+    const seedEntries = `
+export const projectOverview = defineKnowledgeEntry({
+  id: 'project.overview',
+  title: ${JSON.stringify(projectName + ' — project overview')},
+  type: KnowledgeType.Architecture,
+  priority: KnowledgePriority.High,
+  tags: ['overview', 'imported'],
+  appliesWhen: ['onboard', 'plan-work'],
+  summary: ${JSON.stringify(description || 'High-level overview of this project.')},
+  content: ${JSON.stringify(`Imported from ${sourceLabel} via \`shrk import --populate\`. ${description || ''}`.trim())},
+});
+
+export const agentBriefing = defineKnowledgeEntry({
+  id: 'agent.briefing',
+  title: 'AI agent briefing',
+  type: KnowledgeType.Convention,
+  priority: KnowledgePriority.Critical,
+  tags: ['agent', 'safety'],
+  appliesWhen: ['agent-start', 'agent-plan'],
+  content: \`When working in this repo as an AI agent:
+1. Read \\\`shrk brief\\\` for the focused project context (rules + paths + verification).
+2. Use \\\`shrk task "<task>"\\\` to get a per-task packet (relevant rules + templates + commands).
+3. Generate code via \\\`shrk gen <template> <name> --dry-run --save-plan plan.json\\\`, then apply with \\\`shrk apply plan.json --verify-signature --validate\\\`.
+4. Never bypass \\\`shrk check boundaries\\\` — it gates architecture violations.\`,
+});
+
+export const generationSafety = defineKnowledgeEntry({
+  id: 'safety.generation',
+  title: 'Generation safety',
+  type: KnowledgeType.Warning,
+  priority: KnowledgePriority.Critical,
+  tags: ['safety', 'generation'],
+  appliesWhen: ['generate-code', 'overwrite-file'],
+  content: \`shrk gen defaults to dry-run. A real write requires --write AND a clean plan (no conflicts). AI agents must call create_generation_plan via MCP first — never write files directly through MCP.\`,
+});
+`;
+    const knowledgeBlock = rendered.length > 0
+        ? `\nconst imported = [\n${rendered.join(',\n')},\n];\n\nexport default [projectOverview, agentBriefing, generationSafety, ...imported];\n`
+        : `\nexport default [projectOverview, agentBriefing, generationSafety];\n`;
+    return KNOWLEDGE_HELPERS + seedEntries + knowledgeBlock;
+}
+function buildRulesFile(rendered) {
+    return (KNOWLEDGE_HELPERS +
+        '\nconst rules = [\n' +
+        rendered.join(',\n') +
+        (rendered.length > 0 ? ',\n' : '') +
+        '];\n\nexport default rules;\n');
+}
+function buildPathsFile(rendered) {
+    return (KNOWLEDGE_HELPERS +
+        '\nconst paths = [\n' +
+        rendered.join(',\n') +
+        (rendered.length > 0 ? ',\n' : '') +
+        '];\n\nexport default paths;\n');
+}
+// ─── Confidence report ─────────────────────────────────────────────────────
+function buildReportMarkdown(report, sourceLabel) {
+    const lines = [];
+    lines.push('# Imported into populated sharkcraft/');
+    lines.push('');
+    lines.push(`\`shrk import --populate\` parsed ${sourceLabel} and routed each entry into ` +
+        `the canonical \`sharkcraft/*.ts\` files. Re-run with \`--force\` to regenerate.`);
+    lines.push('');
+    lines.push(`## ✅ Adopted directly (${report.adoptedHigh.length} entries — high confidence)`);
+    lines.push('');
+    if (report.adoptedHigh.length === 0) {
+        lines.push('_None._');
+    }
+    else {
+        for (const line of report.adoptedHigh) {
+            lines.push(`- **[${line.kind}] \`${line.id}\`** — ${line.title} _(${line.reason})_`);
+        }
+    }
+    lines.push('');
+    lines.push(`## 🟡 Adopted with review marker (${report.adoptedMedium.length} entries — medium confidence)`);
+    lines.push('');
+    lines.push('These entries had medium priority or a thin body. Written with a ' +
+        '`// TODO: review` comment — read them, decide if they\'re load-bearing, ' +
+        'then either tighten the rule or remove the marker.');
+    lines.push('');
+    if (report.adoptedMedium.length === 0) {
+        lines.push('_None._');
+    }
+    else {
+        for (const line of report.adoptedMedium) {
+            lines.push(`- **[${line.kind}] \`${line.id}\`** — ${line.title} _(${line.reason})_`);
+        }
+    }
+    lines.push('');
+    lines.push(`## ⚠️ Not adopted (${report.dropped.length} entries — low confidence)`);
+    lines.push('');
+    lines.push('These entries had thin bodies (title-only) or were a type that needs a ' +
+        'runnable body (templates). Inspect the original source to decide whether ' +
+        'to author them by hand.');
+    lines.push('');
+    if (report.dropped.length === 0) {
+        lines.push('_None — every entry was strong enough to adopt._');
+    }
+    else {
+        for (const line of report.dropped) {
+            lines.push(`- **[${line.kind}] \`${line.id}\`** — ${line.title} _(${line.reason})_`);
+        }
+    }
+    lines.push('');
+    lines.push(`## ✍️ What \`shrk import\` deliberately doesn't try to recover`);
+    lines.push('');
+    for (const item of report.notInferable)
+        lines.push(`- ${item}`);
+    lines.push('');
+    lines.push('---');
+    lines.push('');
+    lines.push('_Generated by `shrk import --populate`. This report is regenerated each time ' +
+        'you re-run with `--force`._');
+    return lines.join('\n') + '\n';
+}
+const NOT_INFERABLE_DEFAULTS = [
+    'Runnable template bodies — markdown describes templates but doesn\'t give you the scaffold body. Templates land in the dropped list; author them in `sharkcraft/templates.ts`.',
+    'Boundary rules — natural-language "don\'t import X from Y" doesn\'t map cleanly to the structured `from` / `forbiddenImports` shape. Use `shrk init --infer` for layer detection from the import graph.',
+    'Pipeline workflows — sequenced steps with named ids need more structure than a markdown list. Use `shrk init --infer` for pipeline detection from package.json scripts.',
+    'Verification commands — declared in `sharkcraft.config.ts` `verificationCommands[]`, not in knowledge entries. The config file shipped here lists none; add yours.',
+];
+// ─── Public entry point ─────────────────────────────────────────────────────
+/**
+ * Convert a parsed `IImportResult` into populated sharkcraft/*.ts
+ * files plus a companion confidence report.
+ *
+ * Pure function — caller writes the bytes. Same shape as
+ * `synthesizeFromOnboarding` in `@shrkcrft/inspector`.
+ */
+export function synthesizePopulatedFromImport(entries, options) {
+    const filtered = options.filterTags && options.filterTags.length > 0
+        ? entries.filter((e) => e.tags.some((t) => options.filterTags.includes(t)))
+        : entries;
+    const rulesRendered = [];
+    const pathsRendered = [];
+    const knowledgeRendered = [];
+    const adoptedHigh = [];
+    const adoptedMedium = [];
+    const dropped = [];
+    // Sort deterministically by id for stable output.
+    const sorted = [...filtered].sort((a, b) => a.id.localeCompare(b.id));
+    for (const entry of sorted) {
+        const dest = destinationOf(entry);
+        const tier = tierOf(entry);
+        const kindForReport = dest === 'rules' ? 'rule' : dest === 'paths' ? 'path' : dest === 'knowledge' ? 'knowledge' : 'template';
+        if (dest === 'drop' || tier === 'low') {
+            dropped.push({
+                kind: kindForReport,
+                id: entry.id,
+                title: entry.title,
+                reason: dest === 'drop'
+                    ? 'KnowledgeType.Template — needs a runnable body, not recoverable from markdown'
+                    : 'thin body or title-only entry',
+                origin: entry.origin,
+            });
+            continue;
+        }
+        // Always render the `type` field — the knowledge loader requires
+        // it on every entry, even in rules.ts / paths.ts where the file
+        // context might seem to imply it. Validator catches missing-type
+        // as a blocker error otherwise.
+        const rendered = renderEntry(entry, tier, true);
+        if (dest === 'rules')
+            rulesRendered.push(rendered);
+        else if (dest === 'paths')
+            pathsRendered.push(rendered);
+        else
+            knowledgeRendered.push(rendered);
+        const reason = tier === 'high'
+            ? `${entry.priority} priority, ${entry.content.trim().length} chars of body`
+            : `${entry.priority} priority — review the marker`;
+        (tier === 'high' ? adoptedHigh : adoptedMedium).push({
+            kind: kindForReport,
+            id: entry.id,
+            title: entry.title,
+            reason,
+            origin: entry.origin,
+        });
+    }
+    const files = [];
+    files.push({
+        path: 'sharkcraft.config.ts',
+        kind: 'config',
+        content: buildConfigFile({
+            projectName: options.projectName,
+            description: options.description ?? '',
+            includeRules: rulesRendered.length > 0,
+            includePaths: pathsRendered.length > 0,
+        }),
+    });
+    files.push({
+        path: 'knowledge.ts',
+        kind: 'knowledge',
+        content: buildKnowledgeFile(knowledgeRendered, options.projectName, options.description ?? '', options.sourceLabel),
+    });
+    if (rulesRendered.length > 0) {
+        files.push({
+            path: 'rules.ts',
+            kind: 'rules',
+            content: buildRulesFile(rulesRendered),
+        });
+    }
+    if (pathsRendered.length > 0) {
+        files.push({
+            path: 'paths.ts',
+            kind: 'paths',
+            content: buildPathsFile(pathsRendered),
+        });
+    }
+    const report = {
+        adoptedHigh,
+        adoptedMedium,
+        dropped,
+        notInferable: NOT_INFERABLE_DEFAULTS,
+    };
+    files.push({
+        path: '.imported-report.md',
+        kind: 'report-md',
+        content: buildReportMarkdown(report, options.sourceLabel),
+    });
+    files.push({
+        path: '.imported-report.json',
+        kind: 'report-json',
+        content: JSON.stringify({
+            schema: 'sharkcraft.imported-report/v1',
+            sourceLabel: options.sourceLabel,
+            adoptedHigh,
+            adoptedMedium,
+            dropped,
+            notInferable: report.notInferable,
+        }, null, 2) + '\n',
+    });
+    return { files, report };
+}

package/dist/index.d.ts

@@ -8,4 +8,5 @@ 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';
+export * from './emit/synthesize-populated.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +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"}
+{"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;AAC5C,cAAc,gCAAgC,CAAC"}

package/dist/index.js

@@ -8,3 +8,4 @@ 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";
+export * from "./emit/synthesize-populated.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shrkcrft/importer",
-  "version": "0.1.0-alpha.6",
+  "version": "0.1.0-alpha.8",
   "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.6",
-    "@shrkcrft/knowledge": "^0.1.0-alpha.6"
+    "@shrkcrft/core": "^0.1.0-alpha.8",
+    "@shrkcrft/knowledge": "^0.1.0-alpha.8"
   },
   "publishConfig": {
     "access": "public"