@ulpi/cli 0.1.0

package/dist/dist-W7K4WPAF.js

@@ -0,0 +1,597 @@
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  Server,
+  StdioServerTransport
+} from "./chunk-JWUUVXIV.js";
+import {
+  getIncomingEdges,
+  getOutgoingEdges,
+  getTransitiveDeps,
+  getTransitiveRdeps,
+  loadGraph,
+  loadMetrics,
+  loadPageRank
+} from "./chunk-247GVVKK.js";
+import {
+  getCodemapStatus,
+  loadManifest,
+  loadSymbolIndex,
+  runInitPipeline,
+  searchCode,
+  searchSymbols
+} from "./chunk-DBMUNBNB.js";
+import "./chunk-NNUWU6CV.js";
+import "./chunk-YM2HV4IA.js";
+import "./chunk-74WVVWJ4.js";
+import "./chunk-KIKPIH6N.js";
+import "./chunk-2HEE5OKX.js";
+import "./chunk-KLEASXUR.js";
+import {
+  getCurrentBranch
+} from "./chunk-7LXY5UVC.js";
+import "./chunk-4VNS5WPM.js";
+
+// ../../packages/codemap-mcp/dist/index.js
+var searchCodeTool = {
+  name: "search_code",
+  description: "Search code by natural language query. Returns relevant code chunks with file paths, line ranges, and relevance scores.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: { type: "string", description: "Natural language search query" },
+      limit: { type: "number", description: "Maximum results (default 10, max 50)" },
+      pathPrefix: { type: "string", description: "Filter results to files under this path" },
+      includeTests: { type: "boolean", description: "Include test files (default true)" },
+      includeDocs: { type: "boolean", description: "Include markdown/docs files (default true)" }
+    },
+    required: ["query"]
+  }
+};
+async function handleSearchCode(projectDir, args, branch) {
+  const query = args.query;
+  const limit = typeof args.limit === "number" ? Math.min(Math.max(1, args.limit), 50) : 10;
+  const pathPrefix = typeof args.pathPrefix === "string" ? args.pathPrefix : void 0;
+  const includeTests = typeof args.includeTests === "boolean" ? args.includeTests : true;
+  const includeDocs = typeof args.includeDocs === "boolean" ? args.includeDocs : true;
+  const result = await searchCode(projectDir, query, {
+    limit,
+    pathPrefix,
+    includeTests,
+    includeDocs,
+    branch
+  });
+  const payload = {
+    query: result.query,
+    durationMs: result.durationMs,
+    resultCount: result.results.length,
+    results: result.results.map((r) => ({
+      filePath: r.filePath,
+      startLine: r.startLine,
+      endLine: r.endLine,
+      score: Math.round(r.score * 1e3) / 1e3,
+      snippet: r.snippet
+    })),
+    summary: result.results.length > 0 ? `Found ${result.results.length} results for "${query}" in ${result.durationMs}ms` : `No results found for "${query}"`
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+var searchSymbolsTool = {
+  name: "search_symbols",
+  description: "Search for code symbols (functions, classes, interfaces, types) by name. Returns exact, prefix, and substring matches ranked by relevance.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: { type: "string", description: "Symbol name to search for" },
+      symbolType: {
+        type: "string",
+        description: "Filter by symbol type",
+        enum: ["function", "class", "method", "interface", "type", "const", "variable", "enum"]
+      },
+      pathPrefix: { type: "string", description: "Filter results to files under this path" },
+      limit: { type: "number", description: "Maximum results (default 20)" }
+    },
+    required: ["query"]
+  }
+};
+async function handleSearchSymbols(projectDir, args, branch) {
+  const query = args.query;
+  const symbolType = args.symbolType;
+  const pathPrefix = typeof args.pathPrefix === "string" ? args.pathPrefix : void 0;
+  const limit = typeof args.limit === "number" ? Math.min(Math.max(1, args.limit), 100) : 20;
+  const results = searchSymbols(projectDir, query, {
+    symbolType,
+    pathPrefix,
+    limit
+  }, branch);
+  const payload = {
+    query,
+    resultCount: results.length,
+    results: results.map((r) => ({
+      name: r.name,
+      symbolType: r.symbolType,
+      filePath: r.filePath,
+      startLine: r.startLine,
+      endLine: r.endLine,
+      score: r.score
+    })),
+    summary: results.length > 0 ? `Found ${results.length} symbols matching "${query}"` : `No symbols found matching "${query}"`
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+var getFileSummaryTool = {
+  name: "get_file_summary",
+  description: "Get a summary of a specific file in the codemap index: chunks, symbols, and size information.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      filePath: { type: "string", description: "Repository-relative file path" }
+    },
+    required: ["filePath"]
+  }
+};
+async function handleGetFileSummary(projectDir, args, branch) {
+  const filePath = args.filePath;
+  const manifest = loadManifest(projectDir, branch);
+  if (!manifest) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: "Index not initialized", summary: "No codemap index found" }) }]
+    };
+  }
+  const fileEntry = manifest.files[filePath];
+  if (!fileEntry) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: `File not found in index: ${filePath}`, summary: `"${filePath}" is not in the codemap index` }) }]
+    };
+  }
+  const symbols = loadSymbolIndex(projectDir, branch);
+  const fileSymbols = symbols.filter((s) => s.filePath === filePath);
+  const payload = {
+    filePath,
+    chunks: fileEntry.chunkIds.length,
+    sizeBytes: fileEntry.sizeBytes,
+    contentHash: fileEntry.contentHash,
+    symbols: fileSymbols.map((s) => ({
+      name: s.name,
+      type: s.symbolType,
+      line: s.startLine
+    })),
+    summary: `${filePath}: ${fileEntry.chunkIds.length} chunks, ${fileSymbols.length} symbols, ${(fileEntry.sizeBytes / 1024).toFixed(1)} KB`
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+var getIndexStatsTool = {
+  name: "get_index_stats",
+  description: "Get codemap index statistics: file count, chunk count, embedding provider, index size, and status.",
+  inputSchema: {
+    type: "object",
+    properties: {}
+  }
+};
+async function handleGetIndexStats(projectDir, _args, branch) {
+  const status = getCodemapStatus(projectDir, branch);
+  const payload = {
+    ...status,
+    summary: status.initialized ? `CodeMap index: ${status.totalFiles} files, ${status.totalChunks} chunks, ${status.embeddingProvider}/${status.embeddingModel}, mode: ${status.mode}` : "CodeMap index not initialized. Run 'ulpi codemap init' to create the index."
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+var reindexTool = {
+  name: "reindex",
+  description: "Re-index the entire codebase. Creates fresh embeddings for all files. This may take several minutes for large projects.",
+  inputSchema: {
+    type: "object",
+    properties: {}
+  }
+};
+async function handleReindex(projectDir, _args, branch) {
+  const result = await runInitPipeline(projectDir, void 0, branch);
+  const payload = {
+    totalFiles: result.totalFiles,
+    totalChunks: result.totalChunks,
+    durationMs: result.durationMs,
+    embeddingProvider: result.embeddingProvider,
+    embeddingModel: result.embeddingModel,
+    summary: `Re-indexed ${result.totalFiles} files (${result.totalChunks} chunks) in ${(result.durationMs / 1e3).toFixed(1)}s using ${result.embeddingProvider}/${result.embeddingModel}`
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+var getDependenciesTool = {
+  name: "get_dependencies",
+  description: "Get files that a given file depends on (references their definitions). Shows direct or transitive dependencies with shared symbols.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      filePath: { type: "string", description: "Repository-relative file path to get dependencies for" },
+      maxDepth: { type: "number", description: "Maximum traversal depth for transitive dependencies (default 5, max 10)" },
+      includeTransitive: { type: "boolean", description: "Include transitive (indirect) dependencies (default false)" }
+    },
+    required: ["filePath"]
+  }
+};
+async function handleGetDependencies(projectDir, args, branch) {
+  const filePath = args.filePath;
+  const maxDepth = typeof args.maxDepth === "number" ? Math.min(Math.max(1, args.maxDepth), 10) : 5;
+  const includeTransitive = typeof args.includeTransitive === "boolean" ? args.includeTransitive : false;
+  const resolvedBranch = branch ?? getCurrentBranch(projectDir);
+  const graph = loadGraph(projectDir, resolvedBranch);
+  if (!graph) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        error: "Dependency graph not built yet. Run `ulpi codemap init` first."
+      }) }]
+    };
+  }
+  if (!graph.nodes[filePath]) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        error: `File not found in dependency graph: ${filePath}`,
+        summary: `"${filePath}" is not in the dependency graph`
+      }) }]
+    };
+  }
+  if (includeTransitive) {
+    const transitive = getTransitiveDeps(graph, filePath, maxDepth);
+    const payload2 = {
+      filePath,
+      mode: "transitive",
+      maxDepth,
+      dependencyCount: transitive.length,
+      dependencies: transitive.sort(),
+      summary: `${filePath} transitively depends on ${transitive.length} files (depth ${maxDepth})`
+    };
+    return {
+      content: [{ type: "text", text: JSON.stringify(payload2, null, 2) }]
+    };
+  }
+  const edges = getOutgoingEdges(graph, filePath);
+  const dependencies = edges.map((e) => ({
+    filePath: e.target,
+    symbols: e.symbols
+  }));
+  const payload = {
+    filePath,
+    mode: "direct",
+    dependencyCount: dependencies.length,
+    dependencies,
+    summary: `${filePath} directly depends on ${dependencies.length} files`
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+var getDependentsTool = {
+  name: "get_dependents",
+  description: "Get files that depend on a given file (reference it). Shows direct or transitive reverse dependencies with shared symbols.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      filePath: { type: "string", description: "Repository-relative file path to get dependents for" },
+      maxDepth: { type: "number", description: "Maximum traversal depth for transitive dependents (default 5, max 10)" },
+      includeTransitive: { type: "boolean", description: "Include transitive (indirect) dependents (default false)" }
+    },
+    required: ["filePath"]
+  }
+};
+async function handleGetDependents(projectDir, args, branch) {
+  const filePath = args.filePath;
+  const maxDepth = typeof args.maxDepth === "number" ? Math.min(Math.max(1, args.maxDepth), 10) : 5;
+  const includeTransitive = typeof args.includeTransitive === "boolean" ? args.includeTransitive : false;
+  const resolvedBranch = branch ?? getCurrentBranch(projectDir);
+  const graph = loadGraph(projectDir, resolvedBranch);
+  if (!graph) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        error: "Dependency graph not built yet. Run `ulpi codemap init` first."
+      }) }]
+    };
+  }
+  if (!graph.nodes[filePath]) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        error: `File not found in dependency graph: ${filePath}`,
+        summary: `"${filePath}" is not in the dependency graph`
+      }) }]
+    };
+  }
+  if (includeTransitive) {
+    const transitive = getTransitiveRdeps(graph, filePath, maxDepth);
+    const payload2 = {
+      filePath,
+      mode: "transitive",
+      maxDepth,
+      dependentCount: transitive.length,
+      dependents: transitive.sort(),
+      summary: `${transitive.length} files transitively depend on ${filePath} (depth ${maxDepth})`
+    };
+    return {
+      content: [{ type: "text", text: JSON.stringify(payload2, null, 2) }]
+    };
+  }
+  const edges = getIncomingEdges(graph, filePath);
+  const dependents = edges.map((e) => ({
+    filePath: e.source,
+    symbols: e.symbols
+  }));
+  const payload = {
+    filePath,
+    mode: "direct",
+    dependentCount: dependents.length,
+    dependents,
+    summary: `${dependents.length} files directly depend on ${filePath}`
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+var getFileRankTool = {
+  name: "get_file_rank",
+  description: "Get PageRank importance scores for files. Without filePath, returns top-N ranked files. With filePath, returns that file's rank and position.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      filePath: { type: "string", description: "Optional file path to get rank for. Omit to get top-N ranked files." },
+      limit: { type: "number", description: "Maximum number of top files to return (default 20, max 100)" }
+    }
+  }
+};
+async function handleGetFileRank(projectDir, args, branch) {
+  const filePath = typeof args.filePath === "string" ? args.filePath : void 0;
+  const limit = typeof args.limit === "number" ? Math.min(Math.max(1, args.limit), 100) : 20;
+  const resolvedBranch = branch ?? getCurrentBranch(projectDir);
+  const pageRank = loadPageRank(projectDir, resolvedBranch);
+  if (!pageRank) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        error: "Dependency graph not built yet. Run `ulpi codemap init` first."
+      }) }]
+    };
+  }
+  const sorted = Object.entries(pageRank.ranks).map(([file, rank]) => ({ filePath: file, rank })).sort((a, b) => b.rank - a.rank);
+  if (filePath) {
+    const rank = pageRank.ranks[filePath];
+    if (rank === void 0) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          error: `File not found in PageRank data: ${filePath}`,
+          summary: `"${filePath}" is not in the PageRank index`
+        }) }]
+      };
+    }
+    const position = sorted.findIndex((e) => e.filePath === filePath) + 1;
+    const payload2 = {
+      filePath,
+      rank: Math.round(rank * 1e6) / 1e6,
+      position,
+      totalFiles: sorted.length,
+      converged: pageRank.converged,
+      iterations: pageRank.iterations,
+      summary: `${filePath} ranked #${position} of ${sorted.length} files (rank: ${rank.toFixed(6)})`
+    };
+    return {
+      content: [{ type: "text", text: JSON.stringify(payload2, null, 2) }]
+    };
+  }
+  const topFiles = sorted.slice(0, limit).map((e, i) => ({
+    position: i + 1,
+    filePath: e.filePath,
+    rank: Math.round(e.rank * 1e6) / 1e6
+  }));
+  const payload = {
+    totalFiles: sorted.length,
+    showing: topFiles.length,
+    converged: pageRank.converged,
+    iterations: pageRank.iterations,
+    files: topFiles,
+    summary: `Top ${topFiles.length} of ${sorted.length} files by PageRank`
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+var findCyclesTool = {
+  name: "find_cycles",
+  description: "Detect circular dependency cycles in the codebase. Returns groups of files that form dependency cycles.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      limit: { type: "number", description: "Maximum number of cycles to return (default 20, max 100)" }
+    }
+  }
+};
+async function handleFindCycles(projectDir, args, branch) {
+  const limit = typeof args.limit === "number" ? Math.min(Math.max(1, args.limit), 100) : 20;
+  const resolvedBranch = branch ?? getCurrentBranch(projectDir);
+  const metrics = loadMetrics(projectDir, resolvedBranch);
+  if (!metrics) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        error: "Dependency graph not built yet. Run `ulpi codemap init` first."
+      }) }]
+    };
+  }
+  const allCycles = [...metrics.cycles].sort((a, b) => b.files.length - a.files.length);
+  const cycles = allCycles.slice(0, limit).map((c) => ({
+    files: c.files,
+    edgeCount: c.edgeCount,
+    fileCount: c.files.length
+  }));
+  const payload = {
+    totalCycles: allCycles.length,
+    showing: cycles.length,
+    cycles,
+    summary: allCycles.length > 0 ? `Found ${allCycles.length} dependency cycles (showing ${cycles.length})` : "No circular dependency cycles detected"
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+var getCouplingMetricsTool = {
+  name: "get_coupling_metrics",
+  description: "Get module coupling metrics. Shows afferent coupling (Ca), efferent coupling (Ce), and instability index (I) per file. Filter by path prefix.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      modulePath: { type: "string", description: "Path prefix to filter files (e.g. 'src/', 'packages/core/'). Omit to show all files." }
+    }
+  }
+};
+async function handleGetCouplingMetrics(projectDir, args, branch) {
+  const modulePath = typeof args.modulePath === "string" ? args.modulePath : void 0;
+  const resolvedBranch = branch ?? getCurrentBranch(projectDir);
+  const metrics = loadMetrics(projectDir, resolvedBranch);
+  if (!metrics) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        error: "Dependency graph not built yet. Run `ulpi codemap init` first."
+      }) }]
+    };
+  }
+  const filtered = modulePath ? metrics.coupling.filter((c) => c.filePath.startsWith(modulePath)) : metrics.coupling;
+  const sorted = [...filtered].sort((a, b) => b.instability - a.instability);
+  const couplingData = sorted.map((c) => ({
+    filePath: c.filePath,
+    afferentCoupling: c.afferentCoupling,
+    efferentCoupling: c.efferentCoupling,
+    instability: Math.round(c.instability * 1e3) / 1e3
+  }));
+  const avgInstability = sorted.length > 0 ? sorted.reduce((sum, c) => sum + c.instability, 0) / sorted.length : 0;
+  const label = modulePath ? `under "${modulePath}"` : "in the project";
+  const payload = {
+    modulePath: modulePath ?? null,
+    fileCount: couplingData.length,
+    avgInstability: Math.round(avgInstability * 1e3) / 1e3,
+    metrics: couplingData,
+    summary: couplingData.length > 0 ? `${couplingData.length} files ${label} \u2014 avg instability: ${avgInstability.toFixed(3)}` : `No files found ${label} in the dependency graph`
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+var getDepgraphStatsTool = {
+  name: "get_depgraph_stats",
+  description: "Get dependency graph statistics: file count, edge count, definition count, reference count, cycle count, and top-ranked files.",
+  inputSchema: {
+    type: "object",
+    properties: {}
+  }
+};
+async function handleGetDepgraphStats(projectDir, _args, branch) {
+  const resolvedBranch = branch ?? getCurrentBranch(projectDir);
+  const graph = loadGraph(projectDir, resolvedBranch);
+  if (!graph) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        error: "Dependency graph not built yet. Run `ulpi codemap init` first."
+      }) }]
+    };
+  }
+  const pageRank = loadPageRank(projectDir, resolvedBranch);
+  const metrics = loadMetrics(projectDir, resolvedBranch);
+  const fileCount = Object.keys(graph.nodes).length;
+  const edgeCount = graph.edges.length;
+  let totalDefinitions = 0;
+  let totalReferences = 0;
+  for (const node of Object.values(graph.nodes)) {
+    totalDefinitions += node.definitionCount;
+    totalReferences += node.referenceCount;
+  }
+  const topFiles = pageRank ? Object.entries(pageRank.ranks).sort(([, a], [, b]) => b - a).slice(0, 5).map(([file, rank], i) => ({
+    position: i + 1,
+    filePath: file,
+    rank: Math.round(rank * 1e6) / 1e6
+  })) : [];
+  const payload = {
+    generatedAt: graph.generatedAt,
+    fileCount,
+    edgeCount,
+    totalDefinitions,
+    totalReferences,
+    cycleCount: metrics?.cycles.length ?? null,
+    avgFanIn: metrics?.avgFanIn != null ? Math.round(metrics.avgFanIn * 100) / 100 : null,
+    avgFanOut: metrics?.avgFanOut != null ? Math.round(metrics.avgFanOut * 100) / 100 : null,
+    maxFanIn: metrics?.maxFanIn ?? null,
+    maxFanOut: metrics?.maxFanOut ?? null,
+    pageRankConverged: pageRank?.converged ?? null,
+    pageRankIterations: pageRank?.iterations ?? null,
+    topFiles,
+    summary: `Dependency graph: ${fileCount} files, ${edgeCount} edges, ${totalDefinitions} definitions, ${totalReferences} references` + (metrics ? `, ${metrics.cycles.length} cycles` : "")
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+var ALL_TOOLS = [
+  searchCodeTool,
+  searchSymbolsTool,
+  getFileSummaryTool,
+  getIndexStatsTool,
+  reindexTool,
+  getDependenciesTool,
+  getDependentsTool,
+  getFileRankTool,
+  findCyclesTool,
+  getCouplingMetricsTool,
+  getDepgraphStatsTool
+];
+var HANDLERS = {
+  search_code: handleSearchCode,
+  search_symbols: handleSearchSymbols,
+  get_file_summary: handleGetFileSummary,
+  get_index_stats: handleGetIndexStats,
+  reindex: handleReindex,
+  get_dependencies: handleGetDependencies,
+  get_dependents: handleGetDependents,
+  get_file_rank: handleGetFileRank,
+  find_cycles: handleFindCycles,
+  get_coupling_metrics: handleGetCouplingMetrics,
+  get_depgraph_stats: handleGetDepgraphStats
+};
+function createMcpServer(options) {
+  const server = new Server(
+    { name: "codemap", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: ALL_TOOLS
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const handler = HANDLERS[name];
+    if (!handler) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: `Unknown tool: ${name}` }) }],
+        isError: true
+      };
+    }
+    try {
+      return await handler(options.projectDir, args ?? {}, options.branch);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+        isError: true
+      };
+    }
+  });
+  return server;
+}
+async function startMcpServer(options) {
+  const server = createMcpServer(options);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+export {
+  createMcpServer,
+  startMcpServer
+};

package/dist/export-import-4A5MWLIA.js

@@ -0,0 +1,53 @@
+import {
+  parseRules
+} from "./chunk-SIAQVRKG.js";
+import "./chunk-KIKPIH6N.js";
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/export-import.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+async function runExport(args, projectDir) {
+  const outputPath = args[0] ?? "ulpi-rules-export.yml";
+  const rulesPath = path.join(projectDir, ".ulpi", "guards.yml");
+  if (!fs.existsSync(rulesPath)) {
+    console.log(chalk.red("No guards.yml found. Run 'ulpi init' first."));
+    return;
+  }
+  const content = fs.readFileSync(rulesPath, "utf-8");
+  fs.writeFileSync(outputPath, content, "utf-8");
+  console.log(chalk.green(`\u2713 Rules exported to ${outputPath}`));
+}
+async function runImport(args, projectDir) {
+  const inputPath = args[0];
+  if (!inputPath) {
+    console.log(chalk.red("Usage: ulpi import <file-path>"));
+    return;
+  }
+  if (!fs.existsSync(inputPath)) {
+    console.log(chalk.red(`File not found: ${inputPath}`));
+    return;
+  }
+  const rulesDir = path.join(projectDir, ".ulpi");
+  const rulesPath = path.join(rulesDir, "guards.yml");
+  fs.mkdirSync(rulesDir, { recursive: true });
+  const content = fs.readFileSync(inputPath, "utf-8");
+  try {
+    const parsed = parseRules(content);
+    if (!parsed || !parsed.project) {
+      console.log(chalk.red("Error: Invalid rules file \u2014 missing 'project' section."));
+      return;
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.log(chalk.red(`Error: Invalid rules file \u2014 ${message}`));
+    return;
+  }
+  fs.writeFileSync(rulesPath, content, "utf-8");
+  console.log(chalk.green(`\u2713 Rules imported from ${inputPath}`));
+}
+export {
+  runExport,
+  runImport
+};