@cleocode/cant 2026.3.76

package/dist/migrate/types.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Migration types for markdown-to-CANT conversion.
+ *
+ * Defines the input/output contracts for the `cant migrate` command
+ * and the underlying conversion engine.
+ */
+/** Options controlling migration behavior. */
+export interface MigrationOptions {
+    /** Write .cant files to disk (false = dry-run preview). */
+    write: boolean;
+    /** Show detailed conversion log during migration. */
+    verbose: boolean;
+    /** Where to write .cant files (default: .cleo/agents/). */
+    outputDir?: string;
+}
+/** Result of migrating a single markdown file. */
+export interface MigrationResult {
+    /** Absolute path to the input markdown file. */
+    inputFile: string;
+    /** Array of .cant files produced (or that would be produced in dry-run). */
+    outputFiles: ConvertedFile[];
+    /** Sections that could not be automatically converted. */
+    unconverted: UnconvertedSection[];
+    /** Human-readable summary string. */
+    summary: string;
+}
+/** A single converted .cant output file. */
+export interface ConvertedFile {
+    /** Relative path for the output file (e.g. ".cleo/agents/code-reviewer.cant"). */
+    path: string;
+    /** Document kind: agent, skill, hook, or workflow. */
+    kind: string;
+    /** The full .cant file content including frontmatter. */
+    content: string;
+}
+/** A section of markdown that was not converted. */
+export interface UnconvertedSection {
+    /** 1-based line number where the section starts. */
+    lineStart: number;
+    /** 1-based line number where the section ends. */
+    lineEnd: number;
+    /** Human-readable reason why conversion was skipped. */
+    reason: string;
+    /** The raw markdown content of the section. */
+    content: string;
+}
+/**
+ * A parsed markdown section identified by heading.
+ *
+ * Used internally by the markdown parser to structure
+ * the input before classification and conversion.
+ */
+export interface MarkdownSection {
+    /** The heading text (without the `#` prefix). */
+    heading: string;
+    /** The heading level (2 for ##, 3 for ###, etc.). */
+    level: number;
+    /** 1-based line number where the section starts. */
+    lineStart: number;
+    /** 1-based line number where the section ends (inclusive). */
+    lineEnd: number;
+    /** Lines of content below the heading (excluding the heading line). */
+    bodyLines: string[];
+    /** Classified type of this section, determined by heuristic matching. */
+    classification: SectionClassification;
+}
+/** Classification of a markdown section for conversion purposes. */
+export type SectionClassification = 'agent' | 'permissions' | 'hook' | 'skill' | 'workflow' | 'unknown';
+/**
+ * A key-value property extracted from a markdown bullet list.
+ *
+ * Matches patterns like `- **Key**: value` or `- Key: value`.
+ */
+export interface ExtractedProperty {
+    /** Property key (lowercased, normalized). */
+    key: string;
+    /** Property value (trimmed). */
+    value: string;
+}
+/**
+ * A permission entry extracted from markdown.
+ *
+ * Matches patterns like `- Tasks: read, write` or `- Read and write tasks`.
+ */
+export interface ExtractedPermission {
+    /** The domain (e.g. "tasks", "session", "memory"). */
+    domain: string;
+    /** Permission values (e.g. ["read", "write"]). */
+    values: string[];
+}

package/dist/migrate/types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Migration types for markdown-to-CANT conversion.
+ *
+ * Defines the input/output contracts for the `cant migrate` command
+ * and the underlying conversion engine.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/native-loader.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Native addon loader for cant-core via napi-rs
+ *
+ * Loads the napi-rs native addon synchronously. Falls back gracefully
+ * if the native addon is not available (e.g., unsupported platform).
+ *
+ * Replaces the previous wasm-loader.ts which used async WASM initialization.
+ */
+/**
+ * Check if the native addon is available
+ */
+export declare function isNativeAvailable(): boolean;
+/**
+ * Parse a CANT message using the native addon
+ */
+export declare function cantParseNative(content: string): unknown;
+/**
+ * Classify a directive using the native addon
+ */
+export declare function cantClassifyDirectiveNative(verb: string): string;
+export declare const isWasmAvailable: typeof isNativeAvailable;
+export declare const initWasm: () => Promise<void>;

package/dist/native-loader.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Native addon loader for cant-core via napi-rs
+ *
+ * Loads the napi-rs native addon synchronously. Falls back gracefully
+ * if the native addon is not available (e.g., unsupported platform).
+ *
+ * Replaces the previous wasm-loader.ts which used async WASM initialization.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initWasm = exports.isWasmAvailable = void 0;
+exports.isNativeAvailable = isNativeAvailable;
+exports.cantParseNative = cantParseNative;
+exports.cantClassifyDirectiveNative = cantClassifyDirectiveNative;
+let nativeModule = null;
+let loadAttempted = false;
+/**
+ * Attempt to load the native addon. Called lazily on first use.
+ * Native addons load synchronously via require() — no async init needed.
+ */
+function ensureLoaded() {
+    if (loadAttempted)
+        return;
+    loadAttempted = true;
+    try {
+        // Try loading the napi-rs native addon
+        // The package name will be @cleocode/cant-native once published
+        nativeModule = require('@cleocode/cant-native');
+    }
+    catch {
+        try {
+            // Development fallback: try loading from the crate build output
+            nativeModule = require('../../crates/cant-napi');
+        }
+        catch {
+            // Native addon not available — JS fallback will be used
+            nativeModule = null;
+        }
+    }
+}
+/**
+ * Check if the native addon is available
+ */
+function isNativeAvailable() {
+    ensureLoaded();
+    return nativeModule !== null;
+}
+/**
+ * Parse a CANT message using the native addon
+ */
+function cantParseNative(content) {
+    ensureLoaded();
+    if (!nativeModule) {
+        throw new Error('Native addon not available.');
+    }
+    return nativeModule.cantParse(content);
+}
+/**
+ * Classify a directive using the native addon
+ */
+function cantClassifyDirectiveNative(verb) {
+    ensureLoaded();
+    if (!nativeModule) {
+        throw new Error('Native addon not available.');
+    }
+    return nativeModule.cantClassifyDirective(verb);
+}
+// Backward compatibility aliases
+exports.isWasmAvailable = isNativeAvailable;
+const initWasm = async () => {
+    ensureLoaded();
+};
+exports.initWasm = initWasm;

package/dist/parse.d.ts

@@ -0,0 +1,36 @@
+import type { ParsedCANTMessage } from './types';
+export type { ParsedCANTMessage };
+/**
+ * Initialize the CANT parser
+ *
+ * With napi-rs native addons, this is a no-op (native modules load synchronously).
+ * Kept for backward compatibility with code that previously called this for WASM init.
+ *
+ * @example
+ * ```typescript
+ * import { initCantParser, parseCANTMessage } from '@cleocode/cant';
+ *
+ * await initCantParser(); // no-op, kept for compat
+ * const result = parseCANTMessage('/done @all T1234');
+ * ```
+ */
+export declare function initCantParser(): Promise<void>;
+/**
+ * Parse a CANT message
+ *
+ * If the native addon is available, uses the Rust cant-core parser via napi-rs.
+ * Falls back to a basic JavaScript implementation if the native addon is not loaded.
+ *
+ * @param content - The CANT message content to parse
+ * @returns ParsedCANTMessage with directive, addresses, task_refs, tags
+ *
+ * @example
+ * ```typescript
+ * const result = parseCANTMessage('/done @all T1234 #shipped');
+ * console.log(result.directive); // 'done'
+ * console.log(result.addresses); // ['all']
+ * console.log(result.task_refs); // ['T1234']
+ * console.log(result.tags); // ['shipped']
+ * ```
+ */
+export declare function parseCANTMessage(content: string): ParsedCANTMessage;

package/dist/parse.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCantParser = initCantParser;
+exports.parseCANTMessage = parseCANTMessage;
+const native_loader_1 = require("./native-loader");
+/**
+ * Initialize the CANT parser
+ *
+ * With napi-rs native addons, this is a no-op (native modules load synchronously).
+ * Kept for backward compatibility with code that previously called this for WASM init.
+ *
+ * @example
+ * ```typescript
+ * import { initCantParser, parseCANTMessage } from '@cleocode/cant';
+ *
+ * await initCantParser(); // no-op, kept for compat
+ * const result = parseCANTMessage('/done @all T1234');
+ * ```
+ */
+async function initCantParser() {
+    // No-op: napi-rs native addons load synchronously via require().
+    // Kept for backward compatibility.
+}
+/**
+ * Parse a CANT message
+ *
+ * If the native addon is available, uses the Rust cant-core parser via napi-rs.
+ * Falls back to a basic JavaScript implementation if the native addon is not loaded.
+ *
+ * @param content - The CANT message content to parse
+ * @returns ParsedCANTMessage with directive, addresses, task_refs, tags
+ *
+ * @example
+ * ```typescript
+ * const result = parseCANTMessage('/done @all T1234 #shipped');
+ * console.log(result.directive); // 'done'
+ * console.log(result.addresses); // ['all']
+ * console.log(result.task_refs); // ['T1234']
+ * console.log(result.tags); // ['shipped']
+ * ```
+ */
+function parseCANTMessage(content) {
+    // If native addon is available, use it
+    if ((0, native_loader_1.isNativeAvailable)()) {
+        try {
+            const nativeResult = (0, native_loader_1.cantParseNative)(content);
+            return {
+                directive: nativeResult.directive ?? undefined,
+                directive_type: (nativeResult.directiveType?.toLowerCase() ??
+                    'informational'),
+                addresses: nativeResult.addresses ?? [],
+                task_refs: nativeResult.taskRefs ?? [],
+                tags: nativeResult.tags ?? [],
+                header_raw: nativeResult.headerRaw ?? '',
+                body: nativeResult.body ?? '',
+            };
+        }
+        catch (error) {
+            console.warn('Native parsing failed, falling back to JS:', error);
+        }
+    }
+    // Fallback: basic JS implementation (header/body split)
+    const lines = content.split('\n');
+    const header = lines[0] || '';
+    const body = lines.slice(1).join('\n');
+    // Basic regex extraction (not as robust as WASM parser)
+    const directiveMatch = header.match(/^\/([a-z][a-z0-9-]*)/);
+    const addresses = [...header.matchAll(/@([a-zA-Z][a-zA-Z0-9_-]*)/g)].map((m) => m[1]);
+    const taskRefs = [...content.matchAll(/T(\d+)/g)].map((m) => `T${m[1]}`);
+    const tags = [...content.matchAll(/#([a-zA-Z][a-zA-Z0-9_-]*)/g)].map((m) => m[1]);
+    return {
+        directive: directiveMatch ? directiveMatch[1] : undefined,
+        directive_type: directiveMatch ? classifyDirective(directiveMatch[1]) : 'informational',
+        addresses,
+        task_refs: taskRefs,
+        tags,
+        header_raw: header,
+        body,
+    };
+}
+/**
+ * Classify a directive verb into its type
+ *
+ * @param verb - The directive verb (e.g., 'done', 'action', 'info')
+ * @returns 'actionable', 'routing', or 'informational'
+ */
+function classifyDirective(verb) {
+    const actionable = ['claim', 'done', 'blocked', 'approve', 'decision', 'checkin'];
+    const routing = ['action', 'review', 'proposal'];
+    if (actionable.includes(verb))
+        return 'actionable';
+    if (routing.includes(verb))
+        return 'routing';
+    return 'informational';
+}

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+export type DirectiveType = 'actionable' | 'routing' | 'informational';
+export interface ParsedCANTMessage {
+    directive?: string;
+    directive_type: DirectiveType;
+    addresses: string[];
+    task_refs: string[];
+    tags: string[];
+    header_raw: string;
+    body: string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wasm-loader.d.ts

@@ -0,0 +1,31 @@
+/**
+ * WASM loader for cant-core
+ *
+ * Loads the WASM module and provides access to CANT parsing functions
+ */
+/** Shape of the CANT WASM module exports. */
+interface CantWasmModule {
+    default(): Promise<void>;
+    cant_parse(content: string): unknown;
+    cant_classify_directive(verb: string): string;
+}
+declare let wasmModule: CantWasmModule | null;
+/**
+ * Initialize the WASM module
+ * Must be called before using any WASM functions
+ */
+export declare function initWasm(): Promise<void>;
+/**
+ * Check if WASM is available
+ */
+export declare function isWasmAvailable(): boolean;
+/**
+ * Parse a CANT message using WASM
+ */
+export declare function cantParseWASM(content: string): unknown;
+/**
+ * Classify a directive using WASM
+ */
+export declare function cantClassifyDirectiveWASM(verb: string): string;
+export type { CantWasmModule };
+export { wasmModule };

package/dist/wasm-loader.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * WASM loader for cant-core
+ *
+ * Loads the WASM module and provides access to CANT parsing functions
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wasmModule = void 0;
+exports.initWasm = initWasm;
+exports.isWasmAvailable = isWasmAvailable;
+exports.cantParseWASM = cantParseWASM;
+exports.cantClassifyDirectiveWASM = cantClassifyDirectiveWASM;
+// Dynamic import of the WASM module
+let wasmModule = null;
+exports.wasmModule = wasmModule;
+let isInitializing = false;
+let initPromise = null;
+/**
+ * Initialize the WASM module
+ * Must be called before using any WASM functions
+ */
+async function initWasm() {
+    if (wasmModule)
+        return;
+    if (isInitializing) {
+        return initPromise;
+    }
+    isInitializing = true;
+    initPromise = (async () => {
+        try {
+            // Try to load the WASM module
+            const wasm = (await Promise.resolve().then(() => __importStar(require('../wasm/cant_core'))));
+            await wasm.default();
+            exports.wasmModule = wasmModule = wasm;
+        }
+        catch (_error) {
+            console.warn('WASM module not available, falling back to stub implementation');
+            exports.wasmModule = wasmModule = null;
+        }
+    })();
+    await initPromise;
+    isInitializing = false;
+}
+/**
+ * Check if WASM is available
+ */
+function isWasmAvailable() {
+    return wasmModule !== null;
+}
+/**
+ * Parse a CANT message using WASM
+ */
+function cantParseWASM(content) {
+    if (!wasmModule) {
+        throw new Error('WASM not initialized. Call initWasm() first.');
+    }
+    return wasmModule.cant_parse(content);
+}
+/**
+ * Classify a directive using WASM
+ */
+function cantClassifyDirectiveWASM(verb) {
+    if (!wasmModule) {
+        throw new Error('WASM not initialized. Call initWasm() first.');
+    }
+    return wasmModule.cant_classify_directive(verb);
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@cleocode/cant",
+  "version": "2026.3.76",
+  "description": "CANT protocol parser and interpreter for CLEO - wraps cant-core WASM",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/",
+    "wasm/"
+  ],
+  "dependencies": {
+    "@cleocode/contracts": "2026.4.0",
+    "@cleocode/lafs": "2026.4.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  },
+  "keywords": [
+    "cleo",
+    "cant",
+    "agent",
+    "parser",
+    "wasm"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "build:wasm": "cd ../../crates/cant-core && wasm-pack build --target web --features wasm --out-dir ../../packages/cant/wasm",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}