@osovv/grace-cli 3.2.0 → 3.4.0

package/README.md

@@ -10,13 +10,13 @@ This repository packages GRACE as reusable skills for coding agents. The current
 - knowledge-graph synchronization
 - controller-managed sequential or multi-agent implementation
 
-Current packaged version: `3.2.0`
+Current packaged version: `3.4.0`
 
 ## What Changed In This Version
 
-- Documented the published Bun-powered `grace` CLI more explicitly across skills and repo context.
-- Added `grace lint` guidance as a fast integrity preflight alongside reviewer, refresh, and status workflows.
-- Updated the public install example to use `bun add -g @osovv/grace-cli`.
+- Added a rich Python adapter without `pyright` for `grace lint`.
+- Kept TypeScript/JavaScript on the TypeScript compiler API for exact export analysis.
+- Made adapter failures non-fatal so linting can continue with structural checks and warnings.
 
 ## Repository Layout
 
@@ -195,6 +195,17 @@ The lint command is role-aware and adapter-aware:
 - export-map parity uses language adapters where available
 - file behavior is driven by semantic roles instead of filename masks
 
+Current rich adapters:
+
+- TypeScript/JavaScript via the TypeScript compiler API
+- Python via the Python standard-library AST, without `pyright`
+
+Current adapter behavior:
+
+- TypeScript/JavaScript export analysis is treated as exact
+- Python export analysis is exact when `__all__` is explicit, otherwise heuristic
+- other languages still benefit from structural GRACE checks even when rich export analysis is not available yet
+
 Optional `MODULE_CONTRACT` fields for linting:
 
 ```text
@@ -215,16 +226,11 @@ Optional repository config file:
 
 ```json
 {
-  "profile": "auto",
   "ignoredDirs": ["tmp"]
 }
 ```
 
-Profiles:
-
-- `auto` => require `docs/verification-plan.xml` only when the repo already looks verification-aware
-- `current` => require current GRACE artifacts
-- `legacy` => allow older GRACE repos without a verification plan
+`grace lint` is current-only. Older GRACE repositories should fail until they are updated to the current artifact set, especially `docs/verification-plan.xml`.
 
 The validator checks marketplace/plugin metadata sync, version consistency, required fields, `.claude-plugin` structure, and hardcoded absolute paths. In branch or PR context it scopes validation to changed plugins via `git diff origin/main...HEAD`; otherwise it validates all plugins.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@osovv/grace-cli",
-  "version": "3.2.0",
+  "version": "3.4.0",
   "description": "GRACE CLI for linting semantic markup, contracts, and GRACE XML artifacts with a Bun-powered grace binary.",
   "license": "MIT",
   "homepage": "https://github.com/osovv/grace-marketplace#readme",
@@ -16,6 +16,8 @@
     "cli",
     "lint",
     "bun",
+    "python",
+    "typescript",
     "semantic-markup",
     "knowledge-graph"
   ],

package/src/grace-lint.ts

@@ -6,7 +6,6 @@ import { formatTextReport, isValidTextFormat, lintGraceProject } from "./lint/co
 import type { LintOptions, LintResult } from "./lint/types";
 
 export type {
-  EffectiveProfile,
   GraceLintConfig,
   LanguageAdapter,
   LanguageAnalysis,
@@ -16,7 +15,6 @@ export type {
   LintSeverity,
   MapMode,
   ModuleRole,
-  RepoProfile,
 } from "./lint/types";
 
 export { formatTextReport, lintGraceProject } from "./lint/core";
@@ -48,11 +46,6 @@ export const lintCommand = defineCommand({
       description: "Output format: text or json",
       default: "text",
     },
-    profile: {
-      type: "string",
-      description: "Lint profile: auto, current, or legacy",
-      default: "auto",
-    },
     allowMissingDocs: {
       type: "boolean",
       description: "Allow repositories that do not yet have full GRACE docs",
@@ -67,7 +60,6 @@ export const lintCommand = defineCommand({
 
     const result = lintGraceProject(String(context.args.path ?? "."), {
       allowMissingDocs: Boolean(context.args.allowMissingDocs),
-      profile: String(context.args.profile ?? "auto") as LintOptions["profile"],
     });
 
     writeResult(format, result);

package/src/grace.ts

@@ -7,7 +7,7 @@ import { lintCommand } from "./grace-lint";
 const main = defineCommand({
   meta: {
     name: "grace",
-    version: "3.2.0",
+    version: "3.4.0",
     description: "GRACE CLI for linting semantic markup and GRACE project artifacts.",
   },
   subCommands: {

package/src/lint/adapters/base.ts

@@ -1,9 +1,10 @@
 import path from "node:path";
 
 import type { LanguageAdapter } from "../types";
+import { createPythonAdapter } from "./python";
 import { createTypeScriptAdapter } from "./typescript";
 
-const adapters: LanguageAdapter[] = [createTypeScriptAdapter()];
+const adapters: LanguageAdapter[] = [createTypeScriptAdapter(), createPythonAdapter()];
 
 export function getLanguageAdapter(filePath: string) {
   const normalizedPath = path.normalize(filePath);

package/src/lint/adapters/python.ts

@@ -0,0 +1,264 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+
+import type { LanguageAdapter, LanguageAnalysis } from "../types";
+
+const PY_EXTENSIONS = new Set([".py", ".pyi"]);
+const PYTHON_BINARIES = ["python3", "python"];
+
+const PYTHON_ANALYZER_SCRIPT = String.raw`
+import ast
+import json
+import os
+import sys
+
+source = sys.stdin.read()
+file_path = sys.argv[1]
+base_name = os.path.basename(file_path)
+
+
+def is_public(name):
+    return isinstance(name, str) and len(name) > 0 and not name.startswith("_")
+
+
+def extract_target_names(target):
+    if isinstance(target, ast.Name):
+        return [target.id]
+    if isinstance(target, (ast.Tuple, ast.List)):
+        names = []
+        for item in target.elts:
+            names.extend(extract_target_names(item))
+        return names
+    return []
+
+
+def extract_string_sequence(node):
+    if isinstance(node, (ast.List, ast.Tuple, ast.Set)):
+        values = []
+        for element in node.elts:
+            if not isinstance(element, ast.Constant) or not isinstance(element.value, str):
+                return None
+            values.append(element.value)
+        return values
+    return None
+
+
+def is_main_guard(test):
+    if not isinstance(test, ast.Compare):
+        return False
+    if len(test.ops) != 1 or len(test.comparators) != 1:
+        return False
+    left = test.left
+    comparator = test.comparators[0]
+    return (
+        isinstance(left, ast.Name)
+        and left.id == "__name__"
+        and isinstance(test.ops[0], ast.Eq)
+        and isinstance(comparator, ast.Constant)
+        and comparator.value == "__main__"
+    )
+
+
+def imported_name(alias):
+    return alias.asname or alias.name.split(".", 1)[0]
+
+
+local_public = set()
+imported_public = set()
+explicit_all = None
+has_wildcard_reexport = False
+direct_reexport_count = 0
+local_implementation_count = 0
+uses_test_framework = False
+has_main_entrypoint = False
+
+try:
+    tree = ast.parse(source, filename=file_path)
+except SyntaxError as exc:
+    message = f"{exc.msg} at line {exc.lineno}:{exc.offset}" if exc.lineno else exc.msg
+    sys.stderr.write(message)
+    sys.exit(2)
+
+for node in tree.body:
+    if isinstance(node, ast.Import):
+        for alias in node.names:
+            imported = imported_name(alias)
+            if is_public(imported):
+                imported_public.add(imported)
+            if alias.name == "pytest" or alias.name.startswith("unittest"):
+                uses_test_framework = True
+        continue
+
+    if isinstance(node, ast.ImportFrom):
+        module = node.module or ""
+        if module == "pytest" or module.startswith("unittest"):
+            uses_test_framework = True
+        if any(alias.name == "*" for alias in node.names):
+            has_wildcard_reexport = True
+            direct_reexport_count += 1
+            continue
+        public_imports = 0
+        for alias in node.names:
+            imported = imported_name(alias)
+            if is_public(imported):
+                imported_public.add(imported)
+                public_imports += 1
+        if public_imports:
+            direct_reexport_count += 1
+        continue
+
+    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+        local_implementation_count += 1
+        if node.name.startswith("test_"):
+            uses_test_framework = True
+        if is_public(node.name):
+            local_public.add(node.name)
+        continue
+
+    if isinstance(node, ast.ClassDef):
+        local_implementation_count += 1
+        if node.name.startswith("Test"):
+            uses_test_framework = True
+        if is_public(node.name):
+            local_public.add(node.name)
+        continue
+
+    if isinstance(node, ast.Assign):
+        for target in node.targets:
+            for name in extract_target_names(target):
+                if name == "__all__":
+                    sequence = extract_string_sequence(node.value)
+                    if sequence is not None:
+                        explicit_all = sequence
+                    continue
+                if is_public(name):
+                    local_public.add(name)
+                    local_implementation_count += 1
+        continue
+
+    if isinstance(node, ast.AnnAssign):
+        for name in extract_target_names(node.target):
+            if name == "__all__":
+                sequence = extract_string_sequence(node.value)
+                if sequence is not None:
+                    explicit_all = sequence
+                continue
+            if is_public(name):
+                local_public.add(name)
+                local_implementation_count += 1
+        continue
+
+    if isinstance(node, ast.If) and is_main_guard(node.test):
+        has_main_entrypoint = True
+
+if explicit_all is not None:
+    export_names = sorted({name for name in explicit_all if isinstance(name, str)})
+    export_confidence = "exact"
+else:
+    export_names = set(local_public)
+    if base_name == "__init__.py":
+        export_names.update(imported_public)
+    export_names = sorted(export_names)
+    export_confidence = "heuristic"
+
+local_export_count = sum(1 for name in export_names if name in local_public)
+
+print(json.dumps({
+    "exports": export_names,
+    "valueExports": export_names,
+    "typeExports": [],
+    "exportConfidence": export_confidence,
+    "hasDefaultExport": False,
+    "hasWildcardReExport": has_wildcard_reexport,
+    "hasMainEntrypoint": has_main_entrypoint,
+    "directReExportCount": direct_reexport_count,
+    "localExportCount": local_export_count,
+    "localImplementationCount": local_implementation_count,
+    "usesTestFramework": uses_test_framework,
+}))
+`;
+
+function createEmptyAnalysis(): LanguageAnalysis {
+  return {
+    adapterId: "python",
+    exports: new Set<string>(),
+    valueExports: new Set<string>(),
+    typeExports: new Set<string>(),
+    exportConfidence: "heuristic",
+    hasDefaultExport: false,
+    hasWildcardReExport: false,
+    hasMainEntrypoint: false,
+    directReExportCount: 0,
+    localExportCount: 0,
+    localImplementationCount: 0,
+    usesTestFramework: false,
+  };
+}
+
+function normalizeResult(output: string) {
+  const parsed = JSON.parse(output) as {
+    exports: string[];
+    valueExports: string[];
+    typeExports: string[];
+    exportConfidence: "exact" | "heuristic";
+    hasDefaultExport: boolean;
+    hasWildcardReExport: boolean;
+    hasMainEntrypoint: boolean;
+    directReExportCount: number;
+    localExportCount: number;
+    localImplementationCount: number;
+    usesTestFramework: boolean;
+  };
+
+  const analysis = createEmptyAnalysis();
+  analysis.exports = new Set(parsed.exports ?? []);
+  analysis.valueExports = new Set(parsed.valueExports ?? []);
+  analysis.typeExports = new Set(parsed.typeExports ?? []);
+  analysis.exportConfidence = parsed.exportConfidence ?? "heuristic";
+  analysis.hasDefaultExport = Boolean(parsed.hasDefaultExport);
+  analysis.hasWildcardReExport = Boolean(parsed.hasWildcardReExport);
+  analysis.hasMainEntrypoint = Boolean(parsed.hasMainEntrypoint);
+  analysis.directReExportCount = Number(parsed.directReExportCount ?? 0);
+  analysis.localExportCount = Number(parsed.localExportCount ?? 0);
+  analysis.localImplementationCount = Number(parsed.localImplementationCount ?? 0);
+  analysis.usesTestFramework = Boolean(parsed.usesTestFramework);
+  return analysis;
+}
+
+function runPythonAnalyzer(filePath: string, text: string) {
+  for (const binary of PYTHON_BINARIES) {
+    const run = spawnSync(binary, ["-c", PYTHON_ANALYZER_SCRIPT, filePath], {
+      input: text,
+      encoding: "utf8",
+      maxBuffer: 1024 * 1024,
+    });
+
+    if (run.error) {
+      const code = (run.error as NodeJS.ErrnoException).code;
+      if (code === "ENOENT") {
+        continue;
+      }
+      throw run.error;
+    }
+
+    if (run.status === 0) {
+      return normalizeResult(run.stdout);
+    }
+
+    throw new Error(run.stderr.trim() || run.stdout.trim() || `Python analyzer failed via ${binary}.`);
+  }
+
+  throw new Error("Python adapter requires `python3` or `python` on PATH when linting Python files.");
+}
+
+export function createPythonAdapter(): LanguageAdapter {
+  return {
+    id: "python",
+    supports(filePath) {
+      return PY_EXTENSIONS.has(path.extname(filePath));
+    },
+    analyze(filePath, text) {
+      return runPythonAnalyzer(filePath, text);
+    },
+  };
+}

package/src/lint/adapters/typescript.ts

@@ -73,8 +73,10 @@ export function createTypeScriptAdapter(): LanguageAdapter {
         exports: new Set<string>(),
         valueExports: new Set<string>(),
         typeExports: new Set<string>(),
+        exportConfidence: "exact",
         hasDefaultExport: false,
         hasWildcardReExport: false,
+        hasMainEntrypoint: false,
         directReExportCount: 0,
         localExportCount: 0,
         localImplementationCount: 0,

package/src/lint/config.ts

@@ -4,7 +4,7 @@ import path from "node:path";
 import type { GraceLintConfig, LintIssue } from "./types";
 
 const CONFIG_FILE_NAME = ".grace-lint.json";
-const VALID_PROFILES = new Set(["auto", "current", "legacy"]);
+const SUPPORTED_KEYS = new Set(["ignoredDirs"]);
 
 export function loadGraceLintConfig(projectRoot: string) {
   const configPath = path.join(projectRoot, CONFIG_FILE_NAME);
@@ -16,12 +16,26 @@ export function loadGraceLintConfig(projectRoot: string) {
     const parsed = JSON.parse(readFileSync(configPath, "utf8")) as GraceLintConfig;
     const issues: LintIssue[] = [];
 
-    if (parsed.profile && !VALID_PROFILES.has(parsed.profile)) {
+    if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") {
       issues.push({
         severity: "error",
-        code: "config.invalid-profile",
+        code: "config.invalid-shape",
         file: CONFIG_FILE_NAME,
-        message: `Unsupported profile \`${parsed.profile}\` in ${CONFIG_FILE_NAME}. Use \`auto\`, \`current\`, or \`legacy\`.`,
+        message: `${CONFIG_FILE_NAME} must contain a JSON object.`,
+      });
+      return { config: parsed, issues };
+    }
+
+    for (const key of Object.keys(parsed)) {
+      if (SUPPORTED_KEYS.has(key)) {
+        continue;
+      }
+
+      issues.push({
+        severity: "error",
+        code: "config.unknown-key",
+        file: CONFIG_FILE_NAME,
+        message: `Unsupported key \`${key}\` in ${CONFIG_FILE_NAME}. Supported keys: ignoredDirs.`,
       });
     }
 

package/src/lint/core.ts

@@ -4,7 +4,6 @@ import path from "node:path";
 import { loadGraceLintConfig } from "./config";
 import { getLanguageAdapter } from "./adapters/base";
 import type {
-  EffectiveProfile,
   GraceLintConfig,
   LanguageAnalysis,
   LintIssue,
@@ -15,13 +14,9 @@ import type {
   ModuleContractInfo,
   ModuleMapItem,
   ModuleRole,
-  RepoProfile,
 } from "./types";
 
-const REQUIRED_DOCS_BY_PROFILE: Record<EffectiveProfile, string[]> = {
-  legacy: ["docs/knowledge-graph.xml", "docs/development-plan.xml"],
-  current: ["docs/knowledge-graph.xml", "docs/development-plan.xml", "docs/verification-plan.xml"],
-};
+const REQUIRED_DOCS = ["docs/knowledge-graph.xml", "docs/development-plan.xml", "docs/verification-plan.xml"] as const;
 
 const OPTIONAL_PACKET_DOC = "docs/operational-packets.xml";
 const LINT_CONFIG_FILE = ".grace-lint.json";
@@ -46,6 +41,7 @@ const CODE_EXTENSIONS = new Set([
   ".mts",
   ".cts",
   ".py",
+  ".pyi",
   ".go",
   ".java",
   ".kt",
@@ -437,6 +433,10 @@ function inferRole(contract: ModuleContractInfo | null, analysis: LanguageAnalys
     return "CONFIG";
   }
 
+  if (analysis?.hasMainEntrypoint) {
+    return "SCRIPT";
+  }
+
   if (analysis && mentionsScript && analysis.exports.size === 0) {
     return "SCRIPT";
   }
@@ -557,46 +557,6 @@ function lintRequiredPacketSections(result: LintResult, relativePath: string, te
   }
 }
 
-function resolveProfile(
-  requestedProfile: RepoProfile | undefined,
-  configProfile: RepoProfile | undefined,
-  docs: Record<string, string | null>,
-) {
-  const desiredProfile = requestedProfile ?? configProfile ?? "auto";
-  if (desiredProfile !== "auto") {
-    return desiredProfile;
-  }
-
-  const verificationPlan = docs["docs/verification-plan.xml"];
-  if (verificationPlan) {
-    return "current" as const;
-  }
-
-  const joinedDocs = `${docs["docs/knowledge-graph.xml"] ?? ""}\n${docs["docs/development-plan.xml"] ?? ""}`;
-  return /<verification-ref>|<V-M-/.test(joinedDocs) ? "current" : "legacy";
-}
-
-function validateProfileSelection(profile: string | undefined) {
-  if (!profile) {
-    return null;
-  }
-
-  if (profile === "auto" || profile === "current" || profile === "legacy") {
-    return null;
-  }
-
-  return {
-    severity: "error",
-    code: "config.invalid-profile-selection",
-    file: "CLI",
-    message: `Unsupported profile \`${profile}\`. Use \`auto\`, \`current\`, or \`legacy\`.`,
-  } satisfies LintIssue;
-}
-
-function isInvalidProfileIssue(issue: LintIssue) {
-  return issue.code === "config.invalid-profile" || issue.code === "config.invalid-profile-selection";
-}
-
 function lintExportMapParity(
   result: LintResult,
   relativePath: string,
@@ -609,6 +569,17 @@ function lintExportMapParity(
     return;
   }
 
+  const exportSeverity = analysis.exportConfidence === "exact" ? "error" : "warning";
+
+  if (analysis.exportConfidence === "heuristic") {
+    addIssue(result, {
+      severity: "warning",
+      code: "analysis.heuristic-export-surface",
+      file: relativePath,
+      message: `The ${analysis.adapterId} adapter inferred exports heuristically for this file. Exact MODULE_MAP parity may require explicit file ROLE/MAP_MODE or stronger language-specific export declarations.`,
+    });
+  }
+
   if (analysis.hasWildcardReExport) {
     addIssue(result, {
       severity: "warning",
@@ -622,7 +593,7 @@ function lintExportMapParity(
   const mappedSymbols = new Set(items.flatMap((item) => (item.symbolName ? [item.symbolName] : [])));
   if (mappedSymbols.size === 0 && analysis.exports.size > 0) {
     addIssue(result, {
-      severity: "error",
+      severity: exportSeverity,
       code: "markup.module-map-missing-symbol-entries",
       file: relativePath,
       message: "MODULE_MAP should list concrete symbol names when MAP_MODE resolves to EXPORTS.",
@@ -633,7 +604,7 @@ function lintExportMapParity(
   for (const exportName of analysis.exports) {
     if (!mappedSymbols.has(exportName)) {
       addIssue(result, {
-        severity: "error",
+        severity: exportSeverity,
         code: "markup.module-map-missing-export",
         file: relativePath,
         message: `MODULE_MAP is missing the exported symbol \`${exportName}\`.`,
@@ -702,7 +673,19 @@ function lintGovernedFile(result: LintResult, root: string, filePath: string, te
   const contract = moduleContractSection ? parseModuleContract(moduleContractSection) : null;
   const mapItems = moduleMapSection ? parseModuleMapItems(moduleMapSection) : [];
   const adapter = getLanguageAdapter(filePath);
-  const analysis = adapter ? adapter.analyze(filePath, text) : null;
+  let analysis: LanguageAnalysis | null = null;
+  if (adapter) {
+    try {
+      analysis = adapter.analyze(filePath, text);
+    } catch (error) {
+      addIssue(result, {
+        severity: "warning",
+        code: "analysis.adapter-failed",
+        file: relativePath,
+        message: `${adapter.id} adapter failed: ${error instanceof Error ? error.message : String(error)}`,
+      });
+    }
+  }
   const role = inferRole(contract, analysis);
   const mapMode = inferMapMode(contract, role, mapItems, analysis);
 
@@ -771,11 +754,6 @@ function lintGovernedFile(result: LintResult, root: string, filePath: string, te
 export function lintGraceProject(projectRoot: string, options: LintOptions = {}): LintResult {
   const root = path.resolve(projectRoot);
   const { config, issues: configIssues } = loadGraceLintConfig(root);
-  const requestedProfileIssue = validateProfileSelection(options.profile as string | undefined);
-  const effectiveRequestedProfile = requestedProfileIssue ? undefined : options.profile;
-  const effectiveConfigProfile = configIssues.some((issue) => issue.code === "config.invalid-profile")
-    ? undefined
-    : config?.profile;
 
   const docs = {
     "docs/knowledge-graph.xml": readTextIfExists(path.join(root, "docs/knowledge-graph.xml")),
@@ -783,29 +761,26 @@ export function lintGraceProject(projectRoot: string, options: LintOptions = {})
     "docs/verification-plan.xml": readTextIfExists(path.join(root, "docs/verification-plan.xml")),
   } satisfies Record<string, string | null>;
 
-  const profile = resolveProfile(effectiveRequestedProfile, effectiveConfigProfile, docs);
   const result: LintResult = {
     root,
-    profile,
     filesChecked: 0,
     governedFiles: 0,
     xmlFilesChecked: 0,
-    issues: [...configIssues, ...(requestedProfileIssue ? [requestedProfileIssue] : [])],
+    issues: [...configIssues],
   };
 
-  if (configIssues.some((issue) => issue.severity === "error" && issue.file === LINT_CONFIG_FILE && !isInvalidProfileIssue(issue))) {
+  if (configIssues.some((issue) => issue.severity === "error" && issue.file === LINT_CONFIG_FILE)) {
     return result;
   }
 
-  const requiredDocs = REQUIRED_DOCS_BY_PROFILE[profile];
   if (!options.allowMissingDocs) {
-    for (const relativePath of requiredDocs) {
+    for (const relativePath of REQUIRED_DOCS) {
       if (!docs[relativePath]) {
         addIssue(result, {
           severity: "error",
           code: "docs.missing-required-artifact",
           file: relativePath,
-          message: `Missing required GRACE artifact \`${relativePath}\` for the ${profile} profile.`,
+          message: `Missing required current GRACE artifact \`${relativePath}\`.`,
         });
       }
     }
@@ -928,7 +903,6 @@ export function formatTextReport(result: LintResult) {
     "GRACE Lint Report",
     "=================",
     `Root: ${result.root}`,
-    `Profile: ${result.profile}`,
     `Code files checked: ${result.filesChecked}`,
     `Governed files checked: ${result.governedFiles}`,
     `XML files checked: ${result.xmlFilesChecked}`,

package/src/lint/types.ts

@@ -1,8 +1,5 @@
 export type LintSeverity = "error" | "warning";
 
-export type RepoProfile = "auto" | "current" | "legacy";
-export type EffectiveProfile = Exclude<RepoProfile, "auto">;
-
 export type ModuleRole = "RUNTIME" | "TEST" | "BARREL" | "CONFIG" | "TYPES" | "SCRIPT";
 export type MapMode = "EXPORTS" | "LOCALS" | "SUMMARY" | "NONE";
 
@@ -16,7 +13,6 @@ export type LintIssue = {
 
 export type LintResult = {
   root: string;
-  profile: EffectiveProfile;
   filesChecked: number;
   governedFiles: number;
   xmlFilesChecked: number;
@@ -25,11 +21,9 @@ export type LintResult = {
 
 export type LintOptions = {
   allowMissingDocs?: boolean;
-  profile?: RepoProfile;
 };
 
 export type GraceLintConfig = {
-  profile?: RepoProfile;
   ignoredDirs?: string[];
 };
 
@@ -60,8 +54,10 @@ export type LanguageAnalysis = {
   exports: Set<string>;
   valueExports: Set<string>;
   typeExports: Set<string>;
+  exportConfidence: "exact" | "heuristic";
   hasDefaultExport: boolean;
   hasWildcardReExport: boolean;
+  hasMainEntrypoint: boolean;
   directReExportCount: number;
   localExportCount: number;
   localImplementationCount: number;