@shapeshift-labs/frontier-lang-cli 0.3.7 → 0.3.9

package/README.md

@@ -6,6 +6,9 @@ Command line interface for parsing, checking, hashing, and emitting Frontier Lan
 frontier-lang check app.frontier --strict-effects
 frontier-lang emit app.frontier --target rust --out generated.rs
 frontier-lang capabilities app.frontier --target typescript --platform node
+frontier-lang import src/todo.ts --sidecar --out native-import.json
+frontier-lang project-native native-import.json --source-only --out restored.ts
+frontier-lang native-coverage src/todo.ts
 ```
 
 ## Related Packages
@@ -190,7 +193,7 @@ npm install -g @shapeshift-labs/frontier-lang-cli
 frontier-lang check examples/todo.frontier
 ```
 
-Commands: `parse`, `check`, `hash`, `emit`, `emit-ts`, `emit-js`, `emit-rust`, `emit-python`, and `emit-c`.
+Commands: `parse`, `check`, `hash`, `ast`, `capabilities`, `to-json`, `from-json`, `import`, `project-native`, `native-coverage`, `roundtrip`, `corpus-roundtrip`, `emit`, `emit-ts`, `emit-js`, `emit-rust`, `emit-python`, and `emit-c`.
 
 ```sh
 frontier-lang emit app.frontier --target rust --out app.rs

package/dist/index.js

@@ -1,13 +1,18 @@
 #!/usr/bin/env node
-import { readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { parseFrontierFile, parseFrontierSource } from '@shapeshift-labs/frontier-lang-parser';
 import { checkDocument } from '@shapeshift-labs/frontier-lang-checker';
 import { hashDocumentBase } from '@shapeshift-labs/frontier-lang-kernel';
 import {
   compileFrontierDocument,
+  createNativeSourcePreservation,
+  createNativeImportCoverageMatrix,
+  createSemanticImportSidecar,
   createUniversalAstFromDocument,
   importNativeSource,
+  projectNativeImportToSource,
   projectFrontierAst,
   readUniversalAstJson,
   resolveCapabilityAdapters,
@@ -18,6 +23,9 @@ export async function runCli(argv = process.argv.slice(2), io = console) {
   const [command, file, ...rest] = argv;
   if (!command || command === 'help' || command === '--help') return help(io);
   if (!file && command !== 'version') throw new Error(`Missing input file for ${command}`);
+  if (command === 'corpus-roundtrip') {
+    return outputMaybeFile(io, rest, runCorpusRoundtrip(file, rest));
+  }
   const source = file ? readFileSync(file, 'utf8') : '';
   if (command === 'from-json') {
     const envelope = readUniversalAstJson(source);
@@ -27,15 +35,28 @@ export async function runCli(argv = process.argv.slice(2), io = console) {
     return io.log(result.output);
   }
   if (command === 'import') {
+    const imported = importNativeFile(file, source, rest);
+    if (rest.includes('--sidecar-only')) return outputMaybeFile(io, rest, createSemanticImportSidecar(imported));
+    if (rest.includes('--sidecar')) {
+      return outputMaybeFile(io, rest, { import: imported, sidecar: createSemanticImportSidecar(imported) });
+    }
+    return outputMaybeFile(io, rest, imported);
+  }
+  if (command === 'project-native') {
+    const imported = readNativeImportForProjection(file, source, rest);
+    const projection = projectNativeImportToSource(imported, { preferPreservedSource: !rest.includes('--stubs') });
+    if (rest.includes('--source-only')) {
+      const outIndex = rest.indexOf('--out');
+      if (outIndex >= 0 && rest[outIndex + 1]) writeFileSync(rest[outIndex + 1], projection.sourceText);
+      else io.log(projection.sourceText);
+      return;
+    }
+    return outputMaybeFile(io, rest, projection);
+  }
+  if (command === 'native-coverage') {
     const language = readOption(rest, '--language') ?? inferLanguage(file);
-    return outputMaybeFile(io, rest, importNativeSource({
-      language,
-      parser: readOption(rest, '--parser'),
-      sourcePath: file,
-      sourceHash: readOption(rest, '--source-hash'),
-      sourceText: source,
-      nativeAstMetadata: { sourceBytes: source.length }
-    }));
+    const imported = importNativeFile(file, source, rest, { language });
+    return outputMaybeFile(io, rest, createNativeImportCoverageMatrix({ imports: [imported] }));
   }
   const document = file ? parseFrontierFile(file, source) : parseFrontierSource(source);
   if (command === 'to-json') {
@@ -92,8 +113,229 @@ function outputMaybeFile(io, args, value) {
   const outIndex = args.indexOf('--out');
   if (outIndex >= 0 && args[outIndex + 1]) writeFileSync(args[outIndex + 1], json + '\n'); else io.log(json);
 }
-function help(io) { io.log('frontier-lang <parse|check|hash|ast|capabilities|to-json|from-json|import|roundtrip|emit|emit-ts|emit-js|emit-rust|emit-python|emit-c> <file> [--target target] [--language language] [--parser parser] [--platform platform] [--ast] [--out file] [--strict-effects]'); }
+function runCorpusRoundtrip(inputPath, args) {
+  const target = readOption(args, '--target') ?? 'typescript';
+  const entries = collectCorpusEntries(inputPath);
+  const files = entries.map((entry) => corpusRoundtripFile(entry, { target, parser: readOption(args, '--parser') }));
+  const failed = files.filter((fileResult) => !fileResult.ok);
+  return {
+    kind: 'frontier.lang.corpusRoundtrip',
+    version: 1,
+    inputPath,
+    target,
+    total: files.length,
+    passed: files.length - failed.length,
+    failed: failed.length,
+    sourceMapCount: files.reduce((sum, fileResult) => sum + (fileResult.sourceMapCount ?? 0), 0),
+    lossCount: files.reduce((sum, fileResult) => sum + (fileResult.lossCount ?? 0), 0),
+    sourcePreservationCount: files.filter((fileResult) => fileResult.sourcePreservationId).length,
+    projectionModes: files.reduce((counts, fileResult) => {
+      if (fileResult.projectionMode) counts[fileResult.projectionMode] = (counts[fileResult.projectionMode] ?? 0) + 1;
+      return counts;
+    }, {}),
+    readiness: files.reduce((counts, fileResult) => {
+      for (const readiness of fileResult.mergeReadiness ?? []) counts[readiness] = (counts[readiness] ?? 0) + 1;
+      return counts;
+    }, {}),
+    files
+  };
+}
+
+function corpusRoundtripFile(entry, options) {
+  const path = entry.path;
+  try {
+    const source = readFileSync(path, 'utf8');
+    const language = entry.language ?? inferLanguage(path);
+    if (/\.frontier$/i.test(path)) {
+      const document = parseFrontierFile(path, source);
+      const envelope = createUniversalAstFromDocument(document, {
+        evidence: [{ id: `frontier_lang_cli_corpus_${idFragment(path)}`, kind: 'test', status: 'passed', path, summary: 'Corpus Frontier source parsed into universal AST.' }]
+      });
+      const encoded = writeUniversalAstJson(envelope);
+      const decoded = readUniversalAstJson(encoded);
+      const result = compileFrontierDocument(decoded.document, { target: options.target });
+      return {
+        path,
+        language: 'frontier',
+        kind: 'frontierSource',
+        ok: result.ok && decoded.document.id === document.id,
+        hash: result.hash,
+        sourceMapCount: envelope.sourceMaps?.length ?? 0,
+        lossCount: envelope.losses?.length ?? 0,
+        evidenceCount: envelope.evidence?.length ?? 0,
+        diagnostics: result.diagnostics,
+        outputBytes: result.output.length,
+        jsonBytes: encoded.length
+      };
+    }
+    const imported = importNativeSource({
+      language,
+      parser: entry.parser ?? options.parser,
+      sourcePath: path,
+      sourceText: source
+    });
+    const projection = projectNativeImportToSource(imported);
+    const encoded = writeUniversalAstJson(imported.universalAst);
+    const decoded = readUniversalAstJson(encoded);
+    return {
+      path,
+      language,
+      kind: 'nativeSource',
+      ok: decoded.document.id === imported.document.id,
+      sourceMapCount: imported.sourceMaps?.length ?? 0,
+      sourceMapMappingCount: (imported.sourceMaps ?? []).reduce((sum, sourceMap) => sum + (sourceMap.mappings?.length ?? 0), 0),
+      lossCount: imported.losses?.length ?? 0,
+      evidenceCount: imported.evidence?.length ?? 0,
+      symbolCount: imported.semanticIndex?.symbols?.length ?? 0,
+      occurrenceCount: imported.semanticIndex?.occurrences?.length ?? 0,
+      sourcePreservationId: imported.metadata?.sourcePreservationId,
+      sourcePreservationExact: imported.metadata?.sourcePreservation?.summary?.exactSourceAvailable === true,
+      projectionMode: projection.mode,
+      projectionReadiness: projection.readiness?.readiness,
+      projectionLossCount: projection.losses?.length ?? 0,
+      mergeReadiness: (imported.mergeCandidates ?? []).map((candidate) => candidate.readiness),
+      jsonBytes: encoded.length
+    };
+  } catch (error) {
+    return {
+      path,
+      language: entry.language ?? inferLanguage(path),
+      kind: 'error',
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+function collectCorpusEntries(inputPath) {
+  const absolute = resolve(inputPath);
+  const stat = statSync(absolute);
+  if (stat.isDirectory()) {
+    return collectCorpusDirectory(absolute).map((path) => ({ path }));
+  }
+  if (/\.json$/i.test(absolute)) {
+    return readCorpusManifest(absolute);
+  }
+  return [{ path: absolute }];
+}
+
+function collectCorpusDirectory(root) {
+  const files = [];
+  for (const item of readdirSync(root, { withFileTypes: true })) {
+    const path = join(root, item.name);
+    if (item.isDirectory()) {
+      if (!isIgnoredCorpusDirectory(item.name)) files.push(...collectCorpusDirectory(path));
+      continue;
+    }
+    if (item.isFile() && isCorpusSourceFile(path)) files.push(path);
+  }
+  return files.sort();
+}
+
+function readCorpusManifest(path) {
+  const manifest = JSON.parse(readFileSync(path, 'utf8'));
+  const base = dirname(path);
+  const rawEntries = Array.isArray(manifest) ? manifest : manifest.files ?? manifest.entries ?? [];
+  return rawEntries.map((entry) => {
+    if (typeof entry === 'string') return { path: resolve(base, entry) };
+    return {
+      ...entry,
+      path: resolve(base, entry.path ?? entry.file)
+    };
+  });
+}
+
+function importNativeFile(file, source, args, defaults = {}) {
+  const language = defaults.language ?? readOption(args, '--language') ?? inferLanguage(file);
+  const sourceHash = readOption(args, '--source-hash');
+  const sourcePreservation = sourcePreservationOptionsRequested(args)
+    ? createNativeSourcePreservation({
+      language,
+      sourcePath: file,
+      sourceHash,
+      sourceText: source,
+      includeSourceText: !args.includes('--omit-source-text'),
+      includeTokens: !args.includes('--no-tokens'),
+      includeTrivia: !args.includes('--no-trivia'),
+      includeDirectives: !args.includes('--no-directives'),
+      maxTokens: readIntegerOption(args, '--max-tokens'),
+      maxTrivia: readIntegerOption(args, '--max-trivia'),
+      maxDirectives: readIntegerOption(args, '--max-directives'),
+      metadata: { cli: true }
+    })
+    : undefined;
+  return importNativeSource({
+    language,
+    parser: readOption(args, '--parser'),
+    sourcePath: file,
+    sourceHash,
+    sourceText: source,
+    sourcePreservation,
+    nativeAstMetadata: { sourceBytes: source.length }
+  });
+}
+
+function readNativeImportForProjection(file, source, args) {
+  const parsed = tryParseJson(source);
+  if (!parsed) return importNativeFile(file, source, args);
+  if (parsed.kind === 'frontier.lang.universalAst') {
+    const nativeSource = parsed.nativeSources?.[0];
+    return {
+      id: parsed.metadata?.nativeImportId ?? `import_${idFragment(parsed.id)}`,
+      language: parsed.metadata?.sourceLanguage ?? nativeSource?.language ?? readOption(args, '--language') ?? inferLanguage(file),
+      sourcePath: parsed.metadata?.sourcePath ?? nativeSource?.sourcePath,
+      universalAst: parsed,
+      nativeSource,
+      nativeAst: nativeSource?.ast,
+      semanticIndex: parsed.semanticIndex,
+      sourceMaps: parsed.sourceMaps,
+      losses: parsed.losses,
+      evidence: parsed.evidence,
+      metadata: parsed.metadata ?? {}
+    };
+  }
+  return parsed;
+}
+
+function tryParseJson(source) {
+  const trimmed = source.trim();
+  if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) return undefined;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return undefined;
+  }
+}
+
+function isIgnoredCorpusDirectory(name) {
+  return name === 'node_modules' || name === '.git' || name === 'dist' || name === 'coverage' || name === '.next';
+}
+
+function isCorpusSourceFile(path) {
+  return /\.(frontier|[cm]?tsx?|m?jsx?|rs|py|c|h|hpp|cpp|cc|cxx|go|java|kt|cs|swift|php|rb|rake)$/i.test(path);
+}
+
+function idFragment(value) {
+  return String(value ?? 'unknown').replace(/[^A-Za-z0-9]+/g, '_').replace(/^_+|_+$/g, '').toLowerCase() || 'unknown';
+}
+
+function help(io) { io.log('frontier-lang <parse|check|hash|ast|capabilities|to-json|from-json|import|project-native|native-coverage|roundtrip|corpus-roundtrip|emit|emit-ts|emit-js|emit-rust|emit-python|emit-c> <file> [--target target] [--language language] [--parser parser] [--platform platform] [--ast] [--sidecar] [--sidecar-only] [--source-only] [--stubs] [--out file] [--strict-effects]'); }
 function readOption(args, flag) { const index = args.indexOf(flag); return index >= 0 ? args[index + 1] : undefined; }
+function readIntegerOption(args, flag) {
+  const value = readOption(args, flag);
+  if (value === undefined) return undefined;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+function sourcePreservationOptionsRequested(args) {
+  return args.includes('--omit-source-text')
+    || args.includes('--no-tokens')
+    || args.includes('--no-trivia')
+    || args.includes('--no-directives')
+    || args.includes('--max-tokens')
+    || args.includes('--max-trivia')
+    || args.includes('--max-directives');
+}
 function inferLanguage(file) {
   if (!file) return 'unknown';
   if (/\.[cm]?tsx?$/.test(file)) return 'typescript';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-cli",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "description": "Command line interface for parsing, checking, hashing, and emitting Frontier Lang projects.",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,7 +54,7 @@
   },
   "dependencies": {
     "@shapeshift-labs/frontier-lang-checker": "0.3.3",
-    "@shapeshift-labs/frontier-lang-compiler": "0.2.7",
+    "@shapeshift-labs/frontier-lang-compiler": "0.2.10",
     "@shapeshift-labs/frontier-lang-kernel": "0.3.3",
     "@shapeshift-labs/frontier-lang-parser": "0.3.3"
   },