@opencraw/cli 0.1.53 → 0.1.55

package/dist/main.d.ts

@@ -0,0 +1,12 @@
+import type { Terminal } from './terminal';
+/**
+ * Runs one cli invocation: parses argv, dispatches to a use case, writes
+ * through `terminal`. Never throws; a bad command or a use case failure both
+ * become a non-zero return.
+ *
+ * @param argv - Arguments after the program name.
+ * @param terminal - Where output goes.
+ * @returns The process exit code.
+ */
+export declare function main(argv: readonly string[], terminal: Terminal): Promise<number>;
+//# sourceMappingURL=main.d.ts.map

package/dist/probe/index.d.ts

@@ -0,0 +1,6 @@
+export { probePage, probeUrl } from './probe-page.use-case';
+export type { ProbeResult, ProbeOptions } from './probe-page.use-case';
+export { probeReport, pdfReport, workbookReport, deckReport, jsonReport, xmlReport } from './probe-report.mapper';
+export { findData } from '@opencraw/probe';
+export type { ProbeFindings, JsonLdFinding, InlineJsonFinding } from '@opencraw/probe';
+//# sourceMappingURL=index.d.ts.map

package/dist/probe/probe-page.use-case.d.ts

@@ -0,0 +1,65 @@
+import type { AccessConfig, AccessPlugin } from '@opencraw/core';
+import { findData } from '@opencraw/probe';
+import type { DeckFindings, HtmlFindings, JsonFindings, PdfFindings, WorkbookFindings, XmlFindings } from '@opencraw/probe';
+import type { CommonOptions } from '../arguments';
+import type { Terminal } from '../terminal';
+/** What fetching and, optionally, rendering a page found. */
+export interface ProbeResult {
+    url: string;
+    status: number;
+    findings: ReturnType<typeof findData>;
+    /** JSON responses observed while the page rendered; empty unless `options.browser` was set. */
+    observed: string[];
+    /** Present when the URL is a PDF: its rows and likely table headers. */
+    pdf?: PdfFindings;
+    /** Present when the URL is a CSV or a spreadsheet: its sheets, rows and likely table headers. */
+    workbook?: WorkbookFindings;
+    /** Present when the URL is a presentation: its slides, table headers, charts and text-box grids. */
+    deck?: DeckFindings;
+    /** Present when the URL is JSON, JSON Lines or YAML: its structure and record lists. */
+    json?: JsonFindings;
+    /** Present for HTML: its tables' headers; for rendered Markdown also its outline and front matter. */
+    html?: HtmlFindings;
+    /** Present for XML: its namespaces, repeated elements and structure. */
+    xml?: XmlFindings;
+}
+/** How to probe: the cli's options, plus what a service probing for others sets. */
+export interface ProbeOptions extends CommonOptions {
+    /** Also render the page and list the JSON it fetches. */
+    browser: boolean;
+    /** The only hosts the probe may reach, as `CrawlOptions.allowedHosts`; local paths and `file:` are refused. */
+    allowedHosts?: string[];
+    /** An access config already loaded, instead of `access` (a file). `accessProfile` still picks the default. */
+    accessConfig?: AccessConfig;
+    /** Access plugins already loaded, instead of those in `plugins` (a module). */
+    accessPlugins?: AccessPlugin[];
+}
+/**
+ * Fetches a page and finds where its data lives, through the access profile the
+ * options name (direct without one). With `browser: true` it also
+ * renders the page and lists the JSON responses seen while it settles, which
+ * finds endpoints a plain fetch of the initial HTML cannot. No `Terminal`
+ * involved: the cli's `probePage` and `@opencraw/mcp`'s probe tool both
+ * build on this, one printing the result, the other returning it as data.
+ *
+ * A PDF, a spreadsheet, a CSV or a presentation (by content type, or a local
+ * path) is read instead: its rows, and the rows that look like table headers.
+ *
+ * @param url - The page to probe, or a local file path.
+ * @param options - Browser path, TLS and user agent, plus whether to render.
+ * @returns What was found.
+ * @throws Error when the fetch itself fails.
+ */
+export declare function probeUrl(url: string, options: ProbeOptions): Promise<ProbeResult>;
+/**
+ * Fetches a page and reports where its data lives, to a `Terminal`.
+ *
+ * @param url - The page to probe.
+ * @param options - Browser path, TLS and user agent, plus whether to render.
+ * @param terminal - Where the report goes.
+ * @returns The exit code: 0, or 1 on a fetch failure.
+ */
+export declare function probePage(url: string, options: {
+    browser: boolean;
+} & CommonOptions, terminal: Terminal): Promise<number>;
+//# sourceMappingURL=probe-page.use-case.d.ts.map

package/dist/probe/probe-report.mapper.d.ts

@@ -0,0 +1,59 @@
+import type { DeckFindings, HtmlFindings, JsonFindings, PdfFindings, ProbeFindings, WorkbookFindings, XmlFindings } from '@opencraw/probe';
+/**
+ * Renders a probe's findings as text.
+ *
+ * @param url - The URL probed.
+ * @param status - The HTTP status.
+ * @param findings - What `findData` found.
+ * @param observed - JSON responses a browser saw, when `--browser` was used.
+ * @param html - The tables (and, for Markdown, the outline and front matter) found.
+ * @returns The report.
+ */
+export declare function probeReport(url: string, status: number, findings: ProbeFindings, observed?: string[], html?: HtmlFindings): string;
+/**
+ * Renders what a probe found in a PDF as text.
+ *
+ * @param url - The URL or file probed.
+ * @param pdf - What `describePdf` found.
+ * @returns The report.
+ */
+export declare function pdfReport(url: string, pdf: PdfFindings): string;
+/**
+ * Formats what a probe found in a workbook (a CSV or a spreadsheet): its sheets,
+ * the rows that look like table headers with a selector for each, and the first
+ * rows.
+ *
+ * @param url - The workbook's URL.
+ * @param workbook - The findings.
+ * @returns The report.
+ */
+export declare function workbookReport(url: string, workbook: WorkbookFindings): string;
+/**
+ * Formats what a probe found in a deck (a presentation): its slides, the native
+ * tables' headers with a selector for each, its charts, and the slides whose
+ * text boxes look like a table.
+ *
+ * @param url - The deck's URL.
+ * @param deck - The findings.
+ * @returns The report.
+ */
+export declare function deckReport(url: string, deck: DeckFindings): string;
+/**
+ * Formats what a probe found in JSON data: its record lists with the path a
+ * `jsonpath` extract needs, then its structure.
+ *
+ * @param url - The document's URL.
+ * @param json - The findings.
+ * @returns The report.
+ */
+export declare function jsonReport(url: string, json: JsonFindings): string;
+/**
+ * Formats what a probe found in an XML document: its namespaces and the
+ * `namespaces` an `xpath` extract needs, the elements that repeat, and its structure.
+ *
+ * @param url - The document's URL.
+ * @param xml - The findings.
+ * @returns The report.
+ */
+export declare function xmlReport(url: string, xml: XmlFindings): string;
+//# sourceMappingURL=probe-report.mapper.d.ts.map

package/dist/recipe-files/index.d.ts

@@ -0,0 +1,3 @@
+export { readRecipeFiles } from './read-recipe-files.repository';
+export type { RecipeFiles } from './read-recipe-files.repository';
+//# sourceMappingURL=index.d.ts.map

package/dist/recipe-files/read-recipe-files.repository.d.ts

@@ -0,0 +1,26 @@
+import type { RecipeSource } from '@opencraw/core';
+/** Decoded recipes, split by their `kind`. */
+export interface RecipeFiles {
+    /** `path` is the file, `path:line` in a JSON Lines file, or a label (`recipes[0]`) for one from memory. */
+    outputs: {
+        path: string;
+        recipe: unknown;
+    }[];
+    inputs: {
+        path: string;
+        recipe: unknown;
+    }[];
+    /** Documents that are neither; listed so a typo in `kind` does not pass silently. */
+    others: string[];
+}
+/**
+ * Reads recipes, expanding directories to their `.json` and `.jsonl` files
+ * (sorted, not recursive), and sorts them by `kind`. The command line passes
+ * paths; the MCP server also passes recipes it was handed inline.
+ *
+ * @param sources - Files or directories, or any other recipe source core reads.
+ * @returns The decoded recipes.
+ * @throws Error naming a file that is not JSON or JSON Lines.
+ */
+export declare function readRecipeFiles(sources: RecipeSource): Promise<RecipeFiles>;
+//# sourceMappingURL=read-recipe-files.repository.d.ts.map

package/dist/run/index.d.ts

@@ -0,0 +1,3 @@
+export { runRecipes } from './run-recipes.use-case';
+export { loadForRun } from './load-for-run.use-case';
+//# sourceMappingURL=index.d.ts.map

package/dist/run/load-for-run.use-case.d.ts

@@ -0,0 +1,13 @@
+import type { RecipeSet, RecipeSource } from '@opencraw/core';
+/**
+ * Loads and binds the recipes `run` needs, filtered to the input ids in `only`
+ * when given.
+ *
+ * @param sources - Recipe files or directories (or recipes the MCP server was handed inline).
+ * @param only - Input recipe ids to keep; empty keeps all.
+ * @returns The bound set.
+ * @throws Error when there is not exactly one output recipe.
+ * @throws RecipeValidationError, RecipeBindingError on a bad recipe.
+ */
+export declare function loadForRun(sources: RecipeSource, only: readonly string[]): Promise<RecipeSet>;
+//# sourceMappingURL=load-for-run.use-case.d.ts.map

package/dist/run/run-recipes.use-case.d.ts

@@ -0,0 +1,17 @@
+import type { Command } from '../arguments';
+import type { Terminal } from '../terminal';
+/**
+ * Crawls the recipes at `paths` and reports what happened.
+ *
+ * `--dry-run` caps every input at one record, attaches the scope each record
+ * was mapped from, and prints them side by side instead of writing them, so a
+ * recipe under construction can be checked without a full run.
+ *
+ * @param command - The parsed `run` command.
+ * @param terminal - Where records, the trace and errors go.
+ * @returns The exit code: 0, or 1 on a load failure or a recipe error.
+ */
+export declare function runRecipes(command: Extract<Command, {
+    name: 'run';
+}>, terminal: Terminal): Promise<number>;
+//# sourceMappingURL=run-recipes.use-case.d.ts.map

package/dist/studio/index.d.ts

@@ -0,0 +1,3 @@
+export { runStudio } from './run-studio.use-case';
+export type { StudioModule } from './run-studio.use-case';
+//# sourceMappingURL=index.d.ts.map

package/dist/studio/run-studio.use-case.d.ts

@@ -0,0 +1,32 @@
+import { loadPlugins } from '../hooks-module';
+import type { PluginModule } from '../hooks-module';
+import type { Terminal } from '../terminal';
+/** The one export the cli needs from `@opencraw/studio`. */
+export interface StudioModule {
+    main: (argv: readonly string[], options?: {
+        plugins?: PluginModule & {
+            source: string;
+        };
+        open?: string;
+    }) => Promise<void>;
+}
+/**
+ * Runs `opencraw studio [folder]`: imports `@opencraw/studio` lazily and
+ * delegates to its own `main`, which starts the server, prints the URL with
+ * the token, and keeps running until interrupted (Ctrl+C) — the cli's own
+ * call does not return before that. `@opencraw/studio` is an optional peer
+ * dependency (`peerDependenciesMeta`), never a hard one: the cli stays light
+ * for callers who only need to crawl. When it is not installed, this prints
+ * how to add it instead of letting a raw `ERR_MODULE_NOT_FOUND` stack trace
+ * through.
+ *
+ * @param folder - The recipe folder to open; `@opencraw/studio`'s own default (the current directory) when omitted.
+ * @param terminal - Where output goes.
+ * @param importStudio - How the module is loaded; the real dynamic `import()` by default, replaced in tests.
+ * @param pluginsFile - A hooks or plugins module (`--hooks`, issue #150), loaded here, on the command line's own authority, and handed to Studio: the server never loads code itself.
+ * @param load - How the module is read; `loadPlugins` unless a test says otherwise.
+ * @param open - A folder, recipe file or document (`--open`, issue #235): the printed link opens it straight away.
+ * @returns The exit code: 0 once the server has stopped, 1 when `@opencraw/studio` is missing.
+ */
+export declare function runStudio(folder: string | undefined, terminal: Terminal, importStudio?: () => Promise<StudioModule>, pluginsFile?: string, load?: typeof loadPlugins, open?: string): Promise<number>;
+//# sourceMappingURL=run-studio.use-case.d.ts.map

package/dist/terminal/index.d.ts

@@ -0,0 +1,3 @@
+export type { Terminal } from './terminal.contract';
+export { processTerminal } from './terminal.client';
+//# sourceMappingURL=index.d.ts.map

package/dist/terminal/terminal.client.d.ts

@@ -0,0 +1,4 @@
+import type { Terminal } from './terminal.contract';
+/** The process's stdout and stderr. */
+export declare function processTerminal(): Terminal;
+//# sourceMappingURL=terminal.client.d.ts.map

package/dist/terminal/terminal.contract.d.ts

@@ -0,0 +1,6 @@
+/** Where a command writes: results to `out`, diagnostics and progress to `err`. Tests capture both. */
+export interface Terminal {
+    out: (line: string) => void;
+    err: (line: string) => void;
+}
+//# sourceMappingURL=terminal.contract.d.ts.map

package/dist/validate/index.d.ts

@@ -0,0 +1,2 @@
+export { validateRecipes } from './validate-recipes.use-case';
+//# sourceMappingURL=index.d.ts.map

package/dist/validate/validate-recipes.use-case.d.ts

@@ -0,0 +1,10 @@
+import type { Terminal } from '../terminal';
+/**
+ * Loads and binds recipe files, printing every problem with its JSON path.
+ *
+ * @param paths - Recipe files or directories.
+ * @param terminal - Where results go.
+ * @returns The exit code: 0 when the recipes bind cleanly, 1 otherwise.
+ */
+export declare function validateRecipes(paths: readonly string[], terminal: Terminal): Promise<number>;
+//# sourceMappingURL=validate-recipes.use-case.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencraw/cli",
-  "version": "0.1.53",
+  "version": "0.1.55",
   "type": "module",
   "main": "./dist/index.esm.js",
   "module": "./dist/index.esm.js",
@@ -24,12 +24,12 @@
     "!**/*.js.map"
   ],
   "dependencies": {
-    "@opencraw/core": "^0.1.47",
-    "@opencraw/probe": "^0.0.30",
+    "@opencraw/core": "^0.2.0",
+    "@opencraw/probe": "^0.0.32",
     "playwright": "^1.63.0"
   },
   "peerDependencies": {
-    "@opencraw/studio": "^0.0.42"
+    "@opencraw/studio": "^0.0.1"
   },
   "peerDependenciesMeta": {
     "@opencraw/studio": {
@@ -56,39 +56,11 @@
     "node": ">=22"
   },
   "sideEffects": false,
-  "nx": {
-    "targets": {
-      "typecheck": {
-        "dependsOn": [
-          "^build"
-        ]
-      },
-      "lint": {
-        "dependsOn": [
-          "^build"
-        ]
-      },
-      "e2e": {
-        "executor": "nx:run-commands",
-        "dependsOn": [
-          "build",
-          {
-            "projects": [
-              "@opencraw/core"
-            ],
-            "target": "e2e"
-          }
-        ],
-        "inputs": [
-          "default",
-          "^production",
-          "{workspaceRoot}/packages/core/e2e/**"
-        ],
-        "options": {
-          "command": "tsc -p tsconfig.e2e.json && jest --config jest.e2e.config.cts",
-          "cwd": "packages/cli"
-        }
-      }
-    }
+  "scripts": {
+    "build": "esbuild src/index.ts --bundle --packages=external --format=esm --outfile=dist/index.esm.js --sourcemap && tsc -p tsconfig.lib.json --emitDeclarationOnly --declaration --declarationDir dist/src --tsBuildInfoFile dist/src/tsconfig.lib.tsbuildinfo && node ../../declaration-specifiers.mjs dist/src",
+    "e2e": "tsc -p tsconfig.e2e.json && jest --config jest.e2e.config.cts",
+    "lint": "eslint .",
+    "test": "jest",
+    "typecheck": "tsc --build tsconfig.json --emitDeclarationOnly"
   }
 }