@thinkingsage/kanon 0.8.0

package/src/importers/claude-code.ts

@@ -0,0 +1,134 @@
+/**
+ * Claude Code Importer — Compatibility Facade
+ *
+ * Preserves the public `parseClaudeCode` interface while delegating pure parsing
+ * to the Rosetta Stone claude-code-native source translator. Handles multi-file
+ * grouping (CLAUDE.md, settings.json, mcp.json) deterministically.
+ *
+ * For supplementary files (settings.json, mcp.json) that lack a primary CLAUDE.md,
+ * a synthetic primary document is injected so the translator can produce a valid
+ * candidate with extracted hooks/MCP servers.
+ *
+ * Requirements: 14.2, 14.10, 14.11
+ */
+
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { translateClaudeCodeNative } from "../rosetta/builtins/sources/claude-code-native";
+import type { SourceTranslatorContext } from "../rosetta/registry";
+import type {
+	FormatIdentifier,
+	NormalizedRelativePath,
+	SourceDocument,
+} from "../schemas";
+import type { ImportedFile, ImportParser } from "./types";
+
+/**
+ * Derives a kebab-case artifact name from a file path.
+ */
+function deriveArtifactName(filePath: string): string {
+	const base = basename(filePath);
+	const name = base.replace(/\.[^.]+$/, "");
+	return name
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-|-$/g, "");
+}
+
+/**
+ * Claude Code import parser.
+ * Handles CLAUDE.md, .claude/settings.json, and .claude/mcp.json.
+ * Delegates pure parsing to the Rosetta Stone claude-code-native source translator.
+ */
+export const parseClaudeCode: ImportParser = async (
+	filePath: string,
+): Promise<ImportedFile> => {
+	const raw = await readFile(filePath, "utf-8");
+	const base = basename(filePath);
+
+	// Derive artifact name based on file type
+	let artifactName: string;
+	if (base.endsWith("settings.json")) {
+		artifactName = "claude-settings";
+	} else if (base.endsWith("mcp.json")) {
+		artifactName = "claude-mcp";
+	} else {
+		artifactName = deriveArtifactName(filePath);
+	}
+
+	// Build SourceDocument set for Rosetta Stone.
+	// For supplementary files (settings.json, mcp.json) we inject a synthetic
+	// CLAUDE.md so the translator can produce a candidate.
+	const documents: SourceDocument[] = [];
+
+	if (base.endsWith("settings.json") || base.endsWith("mcp.json")) {
+		// Inject a minimal synthetic CLAUDE.md as the primary document
+		documents.push({
+			path: "CLAUDE.md" as NormalizedRelativePath,
+			content: "",
+			executable: false,
+		});
+		documents.push({
+			path: base as NormalizedRelativePath,
+			content: raw,
+			executable: false,
+		});
+	} else {
+		documents.push({
+			path: base as NormalizedRelativePath,
+			content: raw,
+			executable: false,
+		});
+	}
+
+	// Build translator context with the artifact name hint
+	const context: SourceTranslatorContext = {
+		format: {
+			id: "claude-code" as FormatIdentifier,
+		} as SourceTranslatorContext["format"],
+		canonicalSchemaVersion: "1.0.0",
+		options: {},
+		callerContext: { artifactNameHint: artifactName },
+	};
+
+	// Delegate to Rosetta Stone
+	const output = translateClaudeCodeNative(documents, context);
+
+	// Map SourceTranslationOutput back to ImportedFile shape
+	if (output.candidate) {
+		const candidate = output.candidate as Record<string, unknown>;
+		const frontmatter = (candidate.frontmatter ?? {}) as Record<
+			string,
+			unknown
+		>;
+		const {
+			name: _n,
+			type: _t,
+			harnesses: _h,
+			...restFrontmatter
+		} = frontmatter;
+
+		return {
+			sourcePath: filePath,
+			artifactName,
+			body: (candidate.body as string) ?? "",
+			frontmatter: restFrontmatter,
+			hooks: (candidate.hooks as ImportedFile["hooks"]) ?? [],
+			mcpServers: (candidate.mcpServers as ImportedFile["mcpServers"]) ?? [],
+			extraFields: (candidate.extraFields as Record<string, unknown>) ?? {},
+		};
+	}
+
+	// Fallback: if translation produced no candidate, return minimal result
+	return {
+		sourcePath: filePath,
+		artifactName,
+		body: "",
+		frontmatter: {},
+		hooks: [],
+		mcpServers: [],
+		extraFields: {},
+	};
+};
+
+export default parseClaudeCode;

package/src/importers/cline.ts

@@ -0,0 +1,103 @@
+/**
+ * Cline Importer — Compatibility Facade
+ *
+ * Preserves the public `parseCline` interface while delegating pure parsing
+ * to the Rosetta Stone cline-native source translator.
+ *
+ * Requirements: 14.2, 14.10, 14.11
+ */
+
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { translateClineNative } from "../rosetta/builtins/sources/cline-native";
+import type { SourceTranslatorContext } from "../rosetta/registry";
+import type {
+	FormatIdentifier,
+	NormalizedRelativePath,
+	SourceDocument,
+} from "../schemas";
+import type { ImportedFile, ImportParser } from "./types";
+
+/**
+ * Derives a kebab-case artifact name from a file path.
+ */
+function deriveArtifactName(filePath: string): string {
+	const base = basename(filePath);
+	const name = base.replace(/\.md$/, "");
+	return name
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-|-$/g, "");
+}
+
+/**
+ * Cline import parser.
+ * Handles .clinerules/*.md files.
+ * Delegates pure parsing to the Rosetta Stone cline-native source translator.
+ */
+export const parseCline: ImportParser = async (
+	filePath: string,
+): Promise<ImportedFile> => {
+	const raw = await readFile(filePath, "utf-8");
+	const artifactName = deriveArtifactName(filePath);
+
+	// Build SourceDocument for Rosetta Stone
+	const documents: SourceDocument[] = [
+		{
+			path: basename(filePath) as NormalizedRelativePath,
+			content: raw,
+			executable: false,
+		},
+	];
+
+	// Build translator context
+	const context: SourceTranslatorContext = {
+		format: {
+			id: "cline" as FormatIdentifier,
+		} as SourceTranslatorContext["format"],
+		canonicalSchemaVersion: "1.0.0",
+		options: {},
+		callerContext: { artifactNameHint: artifactName },
+	};
+
+	// Delegate to Rosetta Stone
+	const output = translateClineNative(documents, context);
+
+	// Map SourceTranslationOutput back to ImportedFile shape
+	if (output.candidate) {
+		const candidate = output.candidate as Record<string, unknown>;
+		const frontmatter = (candidate.frontmatter ?? {}) as Record<
+			string,
+			unknown
+		>;
+		const {
+			name: _n,
+			type: _t,
+			harnesses: _h,
+			...restFrontmatter
+		} = frontmatter;
+
+		return {
+			sourcePath: filePath,
+			artifactName,
+			body: (candidate.body as string) ?? "",
+			frontmatter: restFrontmatter,
+			hooks: (candidate.hooks as ImportedFile["hooks"]) ?? [],
+			mcpServers: (candidate.mcpServers as ImportedFile["mcpServers"]) ?? [],
+			extraFields: (candidate.extraFields as Record<string, unknown>) ?? {},
+		};
+	}
+
+	// Fallback: if translation produced no candidate, return minimal result
+	return {
+		sourcePath: filePath,
+		artifactName,
+		body: raw.trim(),
+		frontmatter: {},
+		hooks: [],
+		mcpServers: [],
+		extraFields: {},
+	};
+};
+
+export default parseCline;

package/src/importers/codex.ts

@@ -0,0 +1,140 @@
+/**
+ * Codex Importer — Compatibility Facade
+ *
+ * Preserves the public `parseCodex` interface while delegating pure parsing
+ * to the Rosetta Stone codex-native source translator. Handles multi-file
+ * grouping (AGENTS.md, SKILL.md files, config.toml) deterministically.
+ *
+ * For config.toml files (which are supplementary and lack a primary markdown
+ * document), a synthetic AGENTS.md is injected so the translator can produce
+ * a valid candidate with MCP servers extracted.
+ *
+ * Requirements: 14.2, 14.10, 14.11
+ */
+
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { translateCodexNative } from "../rosetta/builtins/sources/codex-native";
+import type { SourceTranslatorContext } from "../rosetta/registry";
+import type {
+	FormatIdentifier,
+	NormalizedRelativePath,
+	SourceDocument,
+} from "../schemas";
+import type { ImportedFile, ImportParser } from "./types";
+
+/**
+ * Derives a kebab-case artifact name from a file path.
+ * For SKILL.md files, prefers the parent directory name.
+ */
+function deriveArtifactName(filePath: string): string {
+	const parts = filePath.split("/");
+	const base = basename(filePath);
+	let name = base.replace(/\.[^.]+$/, "");
+	// `.codex/skills/<name>/SKILL.md` → use the skill directory name
+	if (name.toLowerCase() === "skill" && parts.length >= 2) {
+		name = parts[parts.length - 2];
+	}
+	// `AGENTS.md` → use a stable, descriptive name
+	if (name.toLowerCase() === "agents") {
+		name = "codex-agents";
+	}
+	// `config.toml` → use "codex-mcp" as the artifact name
+	if (base === "config.toml") {
+		return "codex-mcp";
+	}
+	return name
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-|-$/g, "");
+}
+
+/**
+ * Codex import parser.
+ * Handles AGENTS.md, SKILL.md files under .codex/skills and .agents/skills,
+ * and `.codex/config.toml`.
+ * Delegates pure parsing to the Rosetta Stone codex-native source translator.
+ */
+export const parseCodex: ImportParser = async (
+	filePath: string,
+): Promise<ImportedFile> => {
+	const raw = await readFile(filePath, "utf-8");
+	const artifactName = deriveArtifactName(filePath);
+	const base = basename(filePath);
+
+	// Build SourceDocument set for Rosetta Stone.
+	// For config.toml (supplementary file), we inject a synthetic primary
+	// document so the translator can produce a candidate with MCP servers.
+	const documents: SourceDocument[] = [];
+
+	if (base === "config.toml") {
+		// Inject a minimal synthetic AGENTS.md as the primary document
+		documents.push({
+			path: "AGENTS.md" as NormalizedRelativePath,
+			content: "",
+			executable: false,
+		});
+		documents.push({
+			path: base as NormalizedRelativePath,
+			content: raw,
+			executable: false,
+		});
+	} else {
+		documents.push({
+			path: base as NormalizedRelativePath,
+			content: raw,
+			executable: false,
+		});
+	}
+
+	// Build translator context
+	const context: SourceTranslatorContext = {
+		format: {
+			id: "codex" as FormatIdentifier,
+		} as SourceTranslatorContext["format"],
+		canonicalSchemaVersion: "1.0.0",
+		options: {},
+		callerContext: { artifactNameHint: artifactName },
+	};
+
+	// Delegate to Rosetta Stone
+	const output = translateCodexNative(documents, context);
+
+	// Map SourceTranslationOutput back to ImportedFile shape
+	if (output.candidate) {
+		const candidate = output.candidate as Record<string, unknown>;
+		const frontmatter = (candidate.frontmatter ?? {}) as Record<
+			string,
+			unknown
+		>;
+		const {
+			name: _n,
+			type: _t,
+			harnesses: _h,
+			...restFrontmatter
+		} = frontmatter;
+
+		return {
+			sourcePath: filePath,
+			artifactName,
+			body: (candidate.body as string) ?? "",
+			frontmatter: restFrontmatter,
+			hooks: (candidate.hooks as ImportedFile["hooks"]) ?? [],
+			mcpServers: (candidate.mcpServers as ImportedFile["mcpServers"]) ?? [],
+			extraFields: (candidate.extraFields as Record<string, unknown>) ?? {},
+		};
+	}
+
+	// Fallback: if translation produced no candidate, return minimal result
+	return {
+		sourcePath: filePath,
+		artifactName,
+		body: "",
+		frontmatter: {},
+		hooks: [],
+		mcpServers: [],
+		extraFields: {},
+	};
+};
+
+export default parseCodex;

package/src/importers/copilot.ts

@@ -0,0 +1,103 @@
+/**
+ * Copilot Importer — Compatibility Facade
+ *
+ * Preserves the public `parseCopilot` interface while delegating pure parsing
+ * to the Rosetta Stone copilot-native source translator.
+ *
+ * Requirements: 14.2, 14.10, 14.11
+ */
+
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { translateCopilotNative } from "../rosetta/builtins/sources/copilot-native";
+import type { SourceTranslatorContext } from "../rosetta/registry";
+import type {
+	FormatIdentifier,
+	NormalizedRelativePath,
+	SourceDocument,
+} from "../schemas";
+import type { ImportedFile, ImportParser } from "./types";
+
+/**
+ * Derives a kebab-case artifact name from a file path.
+ */
+function deriveArtifactName(filePath: string): string {
+	const base = basename(filePath);
+	const name = base.replace(/\.instructions\.md$/, "").replace(/\.md$/, "");
+	return name
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-|-$/g, "");
+}
+
+/**
+ * Copilot import parser.
+ * Handles .github/copilot-instructions.md and .github/instructions/*.instructions.md.
+ * Delegates pure parsing to the Rosetta Stone copilot-native source translator.
+ */
+export const parseCopilot: ImportParser = async (
+	filePath: string,
+): Promise<ImportedFile> => {
+	const raw = await readFile(filePath, "utf-8");
+	const artifactName = deriveArtifactName(filePath);
+
+	// Build SourceDocument for Rosetta Stone
+	const documents: SourceDocument[] = [
+		{
+			path: basename(filePath) as NormalizedRelativePath,
+			content: raw,
+			executable: false,
+		},
+	];
+
+	// Build translator context
+	const context: SourceTranslatorContext = {
+		format: {
+			id: "copilot" as FormatIdentifier,
+		} as SourceTranslatorContext["format"],
+		canonicalSchemaVersion: "1.0.0",
+		options: {},
+		callerContext: { artifactNameHint: artifactName },
+	};
+
+	// Delegate to Rosetta Stone
+	const output = translateCopilotNative(documents, context);
+
+	// Map SourceTranslationOutput back to ImportedFile shape
+	if (output.candidate) {
+		const candidate = output.candidate as Record<string, unknown>;
+		const frontmatter = (candidate.frontmatter ?? {}) as Record<
+			string,
+			unknown
+		>;
+		const {
+			name: _n,
+			type: _t,
+			harnesses: _h,
+			...restFrontmatter
+		} = frontmatter;
+
+		return {
+			sourcePath: filePath,
+			artifactName,
+			body: (candidate.body as string) ?? "",
+			frontmatter: restFrontmatter,
+			hooks: (candidate.hooks as ImportedFile["hooks"]) ?? [],
+			mcpServers: (candidate.mcpServers as ImportedFile["mcpServers"]) ?? [],
+			extraFields: (candidate.extraFields as Record<string, unknown>) ?? {},
+		};
+	}
+
+	// Fallback: if translation produced no candidate, return minimal result
+	return {
+		sourcePath: filePath,
+		artifactName,
+		body: raw.trim(),
+		frontmatter: {},
+		hooks: [],
+		mcpServers: [],
+		extraFields: {},
+	};
+};
+
+export default parseCopilot;

package/src/importers/cursor.ts

@@ -0,0 +1,105 @@
+/**
+ * Cursor Importer — Compatibility Facade
+ *
+ * Preserves the public `parseCursor` interface while delegating pure parsing
+ * to the Rosetta Stone cursor-native source translator.
+ *
+ * Requirements: 14.2, 14.10, 14.11
+ */
+
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { translateCursorNative } from "../rosetta/builtins/sources/cursor-native";
+import type { SourceTranslatorContext } from "../rosetta/registry";
+import type {
+	FormatIdentifier,
+	NormalizedRelativePath,
+	SourceDocument,
+} from "../schemas";
+import type { ImportedFile, ImportParser } from "./types";
+
+/**
+ * Derives a kebab-case artifact name from a file path.
+ */
+function deriveArtifactName(filePath: string): string {
+	const base = basename(filePath);
+	if (base === ".cursorrules") return "cursorrules";
+	const name = base.replace(/\.md$/, "");
+	return name
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-|-$/g, "");
+}
+
+/**
+ * Cursor import parser.
+ * Handles .cursor/rules/*.md and .cursorrules.
+ * Delegates pure parsing to the Rosetta Stone cursor-native source translator.
+ */
+export const parseCursor: ImportParser = async (
+	filePath: string,
+): Promise<ImportedFile> => {
+	const raw = await readFile(filePath, "utf-8");
+	const artifactName = deriveArtifactName(filePath);
+
+	// Build SourceDocument for Rosetta Stone
+	const documents: SourceDocument[] = [
+		{
+			path: basename(filePath) as NormalizedRelativePath,
+			content: raw,
+			executable: false,
+		},
+	];
+
+	// Build translator context
+	const context: SourceTranslatorContext = {
+		format: {
+			id: "cursor" as FormatIdentifier,
+		} as SourceTranslatorContext["format"],
+		canonicalSchemaVersion: "1.0.0",
+		options: {},
+		callerContext: { artifactNameHint: artifactName },
+	};
+
+	// Delegate to Rosetta Stone
+	const output = translateCursorNative(documents, context);
+
+	// Map SourceTranslationOutput back to ImportedFile shape
+	if (output.candidate) {
+		const candidate = output.candidate as Record<string, unknown>;
+		const frontmatter = (candidate.frontmatter ?? {}) as Record<
+			string,
+			unknown
+		>;
+		// Remove fields that are managed by the import orchestrator
+		const {
+			name: _n,
+			type: _t,
+			harnesses: _h,
+			...restFrontmatter
+		} = frontmatter;
+
+		return {
+			sourcePath: filePath,
+			artifactName,
+			body: (candidate.body as string) ?? "",
+			frontmatter: restFrontmatter,
+			hooks: (candidate.hooks as ImportedFile["hooks"]) ?? [],
+			mcpServers: (candidate.mcpServers as ImportedFile["mcpServers"]) ?? [],
+			extraFields: (candidate.extraFields as Record<string, unknown>) ?? {},
+		};
+	}
+
+	// Fallback: if translation produced no candidate, return minimal result
+	return {
+		sourcePath: filePath,
+		artifactName,
+		body: raw.trim(),
+		frontmatter: {},
+		hooks: [],
+		mcpServers: [],
+		extraFields: {},
+	};
+};
+
+export default parseCursor;