@deepnote/convert 1.3.0 → 2.0.0

package/README.md

@@ -1,13 +1,18 @@
 # @deepnote/convert
 
-Bidirectional converter between Jupyter Notebook files (`.ipynb`) and Deepnote project files (`.deepnote`) with lossless roundtrip support.
+Bidirectional converter between Deepnote project files (`.deepnote`) and multiple notebook formats: Jupyter (`.ipynb`), Quarto (`.qmd`), Percent (`.py`), and Marimo (`.py`).
 
 ```bash
-# Convert a Jupyter notebook to a Deepnote project
+# Convert any supported format to Deepnote
 npx @deepnote/convert notebook.ipynb
-
-# Convert a Deepnote project to Jupyter notebooks
-npx @deepnote/convert project.deepnote
+npx @deepnote/convert document.qmd
+npx @deepnote/convert notebook.py  # percent or marimo format
+
+# Convert Deepnote to any supported format
+npx @deepnote/convert project.deepnote                      # defaults to Jupyter
+npx @deepnote/convert project.deepnote --outputFormat quarto
+npx @deepnote/convert project.deepnote --outputFormat percent
+npx @deepnote/convert project.deepnote --outputFormat marimo
 ```
 
 ## Installation
@@ -16,153 +21,231 @@ npx @deepnote/convert project.deepnote
 npm install -g @deepnote/convert
 ```
 
-## CLI Usage
-
-The package provides a `deepnote-convert` command-line tool for bidirectional conversion between Jupyter and Deepnote formats.
+## Supported Formats
 
-### Convert Jupyter → Deepnote
+| Format      | Extension | Description                                             |
+| ----------- | --------- | ------------------------------------------------------- |
+| **Jupyter** | `.ipynb`  | Standard Jupyter Notebook JSON format                   |
+| **Quarto**  | `.qmd`    | Quarto markdown documents with code chunks              |
+| **Percent** | `.py`     | Python files with `# %%` cell markers (VS Code, Spyder) |
+| **Marimo**  | `.py`     | Marimo reactive notebooks with `@app.cell` decorators   |
 
-#### Convert a Single Notebook
-
-Convert a single `.ipynb` file to a `.deepnote` file:
-
-```bash
-deepnote-convert path/to/notebook.ipynb
-```
+## CLI Usage
 
-This will create a `notebook.deepnote` file in the current directory.
+The package provides a `deepnote-convert` command-line tool for bidirectional conversion.
 
-#### Convert a Directory of Notebooks
+### Convert to Deepnote
 
-Convert all `.ipynb` files in a directory to a single `.deepnote` project:
+Any supported format converts to `.deepnote` automatically:
 
 ```bash
+# Single file
+deepnote-convert notebook.ipynb
+deepnote-convert document.qmd
+deepnote-convert notebook.py  # auto-detects percent vs marimo
+
+# Directory of files
 deepnote-convert path/to/notebooks/
 ```
 
-This will create a `notebooks.deepnote` file in the current directory containing all notebooks from the directory.
+### Convert from Deepnote
 
-### Convert Deepnote → Jupyter
-
-Convert a `.deepnote` file to Jupyter notebooks:
+Use `--outputFormat` to choose the target format (defaults to `jupyter`):
 
 ```bash
-deepnote-convert path/to/project.deepnote
+deepnote-convert project.deepnote                        # → Jupyter notebooks
+deepnote-convert project.deepnote --outputFormat jupyter # → Jupyter notebooks
+deepnote-convert project.deepnote --outputFormat quarto  # → Quarto documents
+deepnote-convert project.deepnote --outputFormat percent # → Percent format files
+deepnote-convert project.deepnote --outputFormat marimo  # → Marimo notebooks
 ```
 
-This will create a `project/` directory containing separate `.ipynb` files for each notebook in the Deepnote project.
-
 ### Options
 
 #### `--projectName <name>`
 
-Set a custom name for the Deepnote project:
+Set a custom name for the Deepnote project (when converting to `.deepnote`):
 
 ```bash
 deepnote-convert notebook.ipynb --projectName "My Analysis"
 ```
 
-If not specified, the project name will default to the filename (without extension) or directory name.
-
 #### `-o, --outputPath <path>`
 
-Specify where to save the output file(s):
+Specify where to save the output:
 
 ```bash
-# For Jupyter → Deepnote: Save to a specific file
+# To Deepnote: Save to a specific file or directory
 deepnote-convert notebook.ipynb -o output/project.deepnote
-
-# For Jupyter → Deepnote: Save to a directory (filename will be auto-generated)
 deepnote-convert notebook.ipynb -o output/
 
-# For Deepnote → Jupyter: Specify output directory for notebooks
-deepnote-convert project.deepnote -o output/jupyter-notebooks/
+# From Deepnote: Specify output directory
+deepnote-convert project.deepnote -o output/notebooks/
 ```
 
-If not specified:
+#### `--outputFormat <format>`
+
+Choose output format when converting from `.deepnote`:
+
+```bash
+deepnote-convert project.deepnote --outputFormat quarto
+```
 
-- For Jupyter → Deepnote: Output file will be saved in the current directory
-- For Deepnote → Jupyter: A directory will be created using the `.deepnote` filename (e.g., `project.deepnote` → `project/`)
+Options: `jupyter` (default), `quarto`, `percent`, `marimo`
 
 ### Examples
 
 ```bash
-# Jupyter → Deepnote: Convert a single notebook with custom name
+# Jupyter → Deepnote
 deepnote-convert titanic.ipynb --projectName "Titanic Analysis"
+deepnote-convert ./notebooks -o ./output
 
-# Jupyter → Deepnote: Convert all notebooks in a directory
-deepnote-convert ./analysis --projectName "Data Science Project" -o ./output
+# Quarto → Deepnote
+deepnote-convert analysis.qmd --projectName "Data Report"
 
-# Jupyter → Deepnote: Convert multiple notebooks from a folder
-deepnote-convert ~/notebooks/ml-experiments -o ~/projects/
+# Percent → Deepnote (auto-detected from # %% markers)
+deepnote-convert script.py
 
-# Deepnote → Jupyter: Convert a Deepnote project to Jupyter notebooks
-deepnote-convert my-project.deepnote
+# Marimo → Deepnote (auto-detected from @app.cell decorators)
+deepnote-convert reactive.py
 
-# Deepnote → Jupyter: Specify output directory
-deepnote-convert my-project.deepnote -o ./jupyter-notebooks/
+# Deepnote → various formats
+deepnote-convert project.deepnote                        # Jupyter (default)
+deepnote-convert project.deepnote --outputFormat quarto  # Quarto
+deepnote-convert project.deepnote --outputFormat percent # Percent
+deepnote-convert project.deepnote --outputFormat marimo  # Marimo
 ```
 
+### Python File Detection
+
+When converting `.py` files, the converter auto-detects the format:
+
+- **Marimo**: Contains `import marimo` and `@app.cell` decorators
+- **Percent**: Contains `# %%` cell markers
+
+For directory scanning, use explicit naming:
+
+- `*.marimo.py` for Marimo files
+- `*.percent.py` for percent format files
+
 ### Lossless Roundtrip Conversion
 
-The converter supports lossless roundtrip conversions:
+The converter supports lossless roundtrip conversions for Jupyter:
 
-- **Deepnote → Jupyter → Deepnote**: Preserves all Deepnote-specific metadata in Jupyter cell metadata, enabling faithful reconstruction of the original notebook's structure and metadata (note: serialization formatting or key ordering may differ)
+- **Deepnote → Jupyter → Deepnote**: Preserves all Deepnote-specific metadata in Jupyter cell metadata
 - **Jupyter → Deepnote → Jupyter**: Preserves original Jupyter content while adding Deepnote metadata
 
-This is achieved by storing Deepnote-specific metadata as flat `deepnote_*` keys directly on Jupyter notebook metadata (e.g., `deepnote_notebook_id`, `deepnote_execution_mode`) and cell metadata (e.g., `deepnote_cell_type`, `deepnote_sorting_key`, `deepnote_source`).
+Other formats (Quarto, Percent, Marimo) preserve content and structure but may not retain all Deepnote-specific metadata.
 
-## Programmatic Usage
+### Platform Compatibility
 
-You can also use the conversion functions programmatically in your Node.js or TypeScript applications.
+Since Jupyter (`.ipynb`) is the standard format, notebooks from cloud platforms that use Jupyter are fully supported with metadata preservation:
 
-### Jupyter → Deepnote
+| Platform               | Status              | Notes                                              |
+| ---------------------- | ------------------- | -------------------------------------------------- |
+| **Google Colab**       | ✅ Fully compatible | Preserves Colab cell IDs, form cells, GPU settings |
+| **Amazon SageMaker**   | ✅ Fully compatible | Preserves tags, training/inference markers         |
+| **Kaggle**             | ✅ Fully compatible | Preserves UUIDs, cell GUIDs, hide input/output     |
+| **Azure ML Notebooks** | ✅ Fully compatible | Standard Jupyter with Azure metadata               |
+| **JupyterLab/Hub**     | ✅ Fully compatible | Standard Jupyter format                            |
+
+Platform-specific cell metadata is preserved during roundtrip conversion, allowing notebooks to be edited in Deepnote and exported back to the original platform without losing settings.
+
+## Programmatic Usage
+
+### Convert to Deepnote
 
 ```typescript
-import { convertIpynbFilesToDeepnoteFile } from "@deepnote/convert";
+import {
+  convertIpynbFilesToDeepnoteFile,
+  convertQuartoFilesToDeepnoteFile,
+  convertPercentFilesToDeepnoteFile,
+  convertMarimoFilesToDeepnoteFile,
+} from "@deepnote/convert";
+
+// From Jupyter
+await convertIpynbFilesToDeepnoteFile(["notebook.ipynb"], {
+  outputPath: "output.deepnote",
+  projectName: "My Project",
+});
 
-await convertIpynbFilesToDeepnoteFile(["path/to/notebook.ipynb"], {
+// From Quarto
+await convertQuartoFilesToDeepnoteFile(["document.qmd"], {
   outputPath: "output.deepnote",
   projectName: "My Project",
 });
-```
 
-### Deepnote → Jupyter
+// From Percent
+await convertPercentFilesToDeepnoteFile(["script.py"], {
+  outputPath: "output.deepnote",
+  projectName: "My Project",
+});
 
-#### File-based Conversion
+// From Marimo
+await convertMarimoFilesToDeepnoteFile(["notebook.py"], {
+  outputPath: "output.deepnote",
+  projectName: "My Project",
+});
+```
 
-For automatic file I/O (reading and writing files):
+### Convert from Deepnote
 
 ```typescript
-import { convertDeepnoteFileToJupyter } from "@deepnote/convert";
-
-await convertDeepnoteFileToJupyter("path/to/project.deepnote", {
+import {
+  convertDeepnoteFileToJupyter,
+  convertDeepnoteFileToQuartoFiles,
+  convertDeepnoteFileToPercentFiles,
+  convertDeepnoteFileToMarimoFiles,
+} from "@deepnote/convert";
+
+// To Jupyter
+await convertDeepnoteFileToJupyter("project.deepnote", {
   outputDir: "./jupyter-notebooks",
 });
+
+// To Quarto
+await convertDeepnoteFileToQuartoFiles("project.deepnote", {
+  outputDir: "./quarto-docs",
+});
+
+// To Percent
+await convertDeepnoteFileToPercentFiles("project.deepnote", {
+  outputDir: "./percent-scripts",
+});
+
+// To Marimo
+await convertDeepnoteFileToMarimoFiles("project.deepnote", {
+  outputDir: "./marimo-notebooks",
+});
 ```
 
-#### Pure Conversion (No File I/O)
+### Pure Conversion (No File I/O)
 
 For programmatic use with in-memory data:
 
 ```typescript
 import fs from "node:fs/promises";
 import { deserializeDeepnoteFile } from "@deepnote/blocks";
-import { convertDeepnoteToJupyterNotebooks } from "@deepnote/convert";
+import {
+  convertDeepnoteToJupyterNotebooks,
+  convertDeepnoteToQuartoDocuments,
+  convertDeepnoteToPercentNotebooks,
+  convertDeepnoteToMarimoApps,
+} from "@deepnote/convert";
 
 // Read and deserialize the Deepnote file
 const yamlContent = await fs.readFile("project.deepnote", "utf-8");
 const deepnoteFile = deserializeDeepnoteFile(yamlContent);
 
-// Convert to Jupyter notebooks (pure function, no I/O)
-const notebooks = convertDeepnoteToJupyterNotebooks(deepnoteFile);
+// Convert to any format (pure functions, no I/O)
+const jupyterNotebooks = convertDeepnoteToJupyterNotebooks(deepnoteFile);
+const quartoDocuments = convertDeepnoteToQuartoDocuments(deepnoteFile);
+const percentNotebooks = convertDeepnoteToPercentNotebooks(deepnoteFile);
+const marimoApps = convertDeepnoteToMarimoApps(deepnoteFile);
 
-// Now you can work with the notebooks in memory
-for (const { filename, notebook } of notebooks) {
+// Work with the results in memory
+for (const { filename, notebook } of jupyterNotebooks) {
   console.log(`${filename}: ${notebook.cells.length} cells`);
-
-  // Or save them yourself
-  await fs.writeFile(filename, JSON.stringify(notebook, null, 2));
 }
 ```
 

package/dist/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as convertDeepnoteFileToJupyterFiles, t as convertIpynbFilesToDeepnoteFile } from "./src-j4HyYJfD.js";
+import { T as convertDeepnoteFileToMarimoFiles, _ as convertDeepnoteFileToQuartoFiles, a as convertPercentFilesToDeepnoteFile, d as convertMarimoFilesToDeepnoteFile, k as convertDeepnoteFileToJupyterFiles, p as convertIpynbFilesToDeepnoteFile, r as convertQuartoFilesToDeepnoteFile, x as convertDeepnoteFileToPercentFiles } from "./src-CUESP0m8.js";
 import { cli } from "cleye";
 import fs from "node:fs/promises";
 import { basename, extname, resolve } from "node:path";
@@ -8,7 +8,7 @@ import ora from "ora";
 
 //#region src/cli.ts
 async function convert(options) {
-	const { inputPath, projectName: customProjectName, outputPath: customOutputPath, cwd = process.cwd() } = options;
+	const { inputPath, projectName: customProjectName, outputPath: customOutputPath, cwd = process.cwd(), outputFormat = "jupyter" } = options;
 	const resolveProjectName = (possibleName) => {
 		if (customProjectName) return customProjectName;
 		if (possibleName) return possibleName;
@@ -24,56 +24,165 @@ async function convert(options) {
 	};
 	const absolutePath = resolve(cwd, inputPath);
 	if ((await fs.stat(absolutePath)).isDirectory()) {
-		const ipynbFiles = (await fs.readdir(absolutePath, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".ipynb")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
-		if (ipynbFiles.length === 0) throw new Error("No .ipynb files found in the specified directory.");
-		const spinner = ora("Converting Jupyter Notebooks to a Deepnote project...").start();
-		try {
-			const filenameWithoutExtension = basename(absolutePath);
-			const projectName = resolveProjectName(filenameWithoutExtension);
-			const outputPath = await resolveOutputPath(`${filenameWithoutExtension}.deepnote`);
-			await convertIpynbFilesToDeepnoteFile(ipynbFiles.map((file) => resolve(absolutePath, file)), {
-				projectName,
-				outputPath
-			});
-			spinner.succeed(`The Deepnote project has been saved to ${chalk.bold(outputPath)}`);
-			return outputPath;
-		} catch (error) {
-			spinner.fail("Conversion failed");
-			throw error;
+		const entries = await fs.readdir(absolutePath, { withFileTypes: true });
+		const ipynbFiles = entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".ipynb")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+		const quartoFiles = entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".qmd")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+		const pyFiles = entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".py")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+		const classifyPyFile = async (pyFile) => {
+			const content = await fs.readFile(resolve(absolutePath, pyFile), "utf-8");
+			if (isMarimoContent(content)) return {
+				file: pyFile,
+				type: "marimo"
+			};
+			if (isPercentContent(content)) return {
+				file: pyFile,
+				type: "percent"
+			};
+			return {
+				file: pyFile,
+				type: "unknown"
+			};
+		};
+		const CONCURRENCY_LIMIT = 10;
+		const results = [];
+		for (let i = 0; i < pyFiles.length; i += CONCURRENCY_LIMIT) {
+			const batch = pyFiles.slice(i, i + CONCURRENCY_LIMIT);
+			const batchResults = await Promise.all(batch.map(classifyPyFile));
+			results.push(...batchResults);
 		}
+		const marimoFiles = results.filter((r) => r.type === "marimo").map((r) => r.file);
+		const percentFiles = results.filter((r) => r.type === "percent").map((r) => r.file);
+		if (ipynbFiles.length > 0) return convertDirectory(absolutePath, ipynbFiles, "jupyter", resolveProjectName, resolveOutputPath);
+		if (quartoFiles.length > 0) return convertDirectory(absolutePath, quartoFiles, "quarto", resolveProjectName, resolveOutputPath);
+		if (marimoFiles.length > 0) return convertDirectory(absolutePath, marimoFiles, "marimo", resolveProjectName, resolveOutputPath);
+		if (percentFiles.length > 0) return convertDirectory(absolutePath, percentFiles, "percent", resolveProjectName, resolveOutputPath);
+		throw new Error("No supported notebook files found in the specified directory (.ipynb, .qmd, .py)");
 	}
 	const ext = extname(absolutePath).toLowerCase();
-	if (ext === ".ipynb") {
-		const spinner = ora("Converting the Jupyter Notebook to a Deepnote project...").start();
-		try {
-			const filenameWithoutExtension = basename(absolutePath, ext);
-			const projectName = resolveProjectName(filenameWithoutExtension);
-			const outputPath = await resolveOutputPath(`${filenameWithoutExtension}.deepnote`);
-			await convertIpynbFilesToDeepnoteFile([absolutePath], {
-				projectName,
-				outputPath
-			});
-			spinner.succeed(`The Deepnote project has been saved to ${chalk.bold(outputPath)}`);
-			return outputPath;
-		} catch (error) {
-			spinner.fail("Conversion failed");
-			throw error;
+	if (ext === ".ipynb") return convertJupyterToDeepnote(absolutePath, resolveProjectName, resolveOutputPath);
+	if (ext === ".qmd") return convertQuartoToDeepnote(absolutePath, resolveProjectName, resolveOutputPath);
+	if (ext === ".py") {
+		const content = await fs.readFile(absolutePath, "utf-8");
+		if (isMarimoContent(content)) return convertMarimoToDeepnote(absolutePath, resolveProjectName, resolveOutputPath);
+		if (isPercentContent(content)) return convertPercentToDeepnote(absolutePath, resolveProjectName, resolveOutputPath);
+		throw new Error("Unsupported Python file format. File must be a percent format (# %% markers) or Marimo notebook (@app.cell decorators).");
+	}
+	if (ext === ".deepnote") return convertDeepnoteToFormat(absolutePath, outputFormat, customOutputPath, cwd);
+	throw new Error("Unsupported file type. Please provide a .ipynb, .qmd, .py (percent/marimo), or .deepnote file.");
+}
+async function convertDirectory(dirPath, files, format, resolveProjectName, resolveOutputPath) {
+	const spinner = ora(`Converting ${{
+		jupyter: "Jupyter Notebooks",
+		quarto: "Quarto documents",
+		percent: "percent format notebooks",
+		marimo: "Marimo notebooks"
+	}[format]} to a Deepnote project...`).start();
+	try {
+		const filenameWithoutExtension = basename(dirPath);
+		const projectName = resolveProjectName(filenameWithoutExtension);
+		const outputPath = await resolveOutputPath(`${filenameWithoutExtension}.deepnote`);
+		const inputFilePaths = files.map((file) => resolve(dirPath, file));
+		switch (format) {
+			case "jupyter":
+				await convertIpynbFilesToDeepnoteFile(inputFilePaths, {
+					projectName,
+					outputPath
+				});
+				break;
+			case "quarto":
+				await convertQuartoFilesToDeepnoteFile(inputFilePaths, {
+					projectName,
+					outputPath
+				});
+				break;
+			case "percent":
+				await convertPercentFilesToDeepnoteFile(inputFilePaths, {
+					projectName,
+					outputPath
+				});
+				break;
+			case "marimo":
+				await convertMarimoFilesToDeepnoteFile(inputFilePaths, {
+					projectName,
+					outputPath
+				});
+				break;
 		}
+		spinner.succeed(`The Deepnote project has been saved to ${chalk.bold(outputPath)}`);
+		return outputPath;
+	} catch (error) {
+		spinner.fail("Conversion failed");
+		throw error;
+	}
+}
+async function convertSingleFileToDeepnote(absolutePath, formatName, converter, resolveProjectName, resolveOutputPath) {
+	const spinner = ora(`Converting the ${formatName} to a Deepnote project...`).start();
+	try {
+		const filenameWithoutExtension = basename(absolutePath, extname(absolutePath));
+		const projectName = resolveProjectName(filenameWithoutExtension);
+		const outputPath = await resolveOutputPath(`${filenameWithoutExtension}.deepnote`);
+		await converter([absolutePath], {
+			projectName,
+			outputPath
+		});
+		spinner.succeed(`The Deepnote project has been saved to ${chalk.bold(outputPath)}`);
+		return outputPath;
+	} catch (error) {
+		spinner.fail("Conversion failed");
+		throw error;
 	}
-	if (ext === ".deepnote") {
-		const spinner = ora("Converting Deepnote project to Jupyter Notebooks...").start();
-		try {
-			const outputDirName = basename(absolutePath, ext);
-			const outputDir = customOutputPath ? resolve(cwd, customOutputPath) : resolve(cwd, outputDirName);
-			await convertDeepnoteFileToJupyterFiles(absolutePath, { outputDir });
-			spinner.succeed(`Jupyter Notebooks have been saved to ${chalk.bold(outputDir)}`);
-			return outputDir;
-		} catch (error) {
-			spinner.fail("Conversion failed");
-			throw error;
+}
+function convertJupyterToDeepnote(absolutePath, resolveProjectName, resolveOutputPath) {
+	return convertSingleFileToDeepnote(absolutePath, "Jupyter Notebook", convertIpynbFilesToDeepnoteFile, resolveProjectName, resolveOutputPath);
+}
+function convertQuartoToDeepnote(absolutePath, resolveProjectName, resolveOutputPath) {
+	return convertSingleFileToDeepnote(absolutePath, "Quarto document", convertQuartoFilesToDeepnoteFile, resolveProjectName, resolveOutputPath);
+}
+function convertPercentToDeepnote(absolutePath, resolveProjectName, resolveOutputPath) {
+	return convertSingleFileToDeepnote(absolutePath, "percent format notebook", convertPercentFilesToDeepnoteFile, resolveProjectName, resolveOutputPath);
+}
+function convertMarimoToDeepnote(absolutePath, resolveProjectName, resolveOutputPath) {
+	return convertSingleFileToDeepnote(absolutePath, "Marimo notebook", convertMarimoFilesToDeepnoteFile, resolveProjectName, resolveOutputPath);
+}
+async function convertDeepnoteToFormat(absolutePath, outputFormat, customOutputPath, cwd) {
+	const formatNames = {
+		jupyter: "Jupyter Notebooks",
+		percent: "percent format files",
+		quarto: "Quarto documents",
+		marimo: "Marimo notebooks"
+	};
+	const spinner = ora(`Converting Deepnote project to ${formatNames[outputFormat]}...`).start();
+	try {
+		const outputDirName = basename(absolutePath, extname(absolutePath));
+		const outputDir = customOutputPath ? resolve(cwd, customOutputPath) : resolve(cwd, outputDirName);
+		switch (outputFormat) {
+			case "jupyter":
+				await convertDeepnoteFileToJupyterFiles(absolutePath, { outputDir });
+				break;
+			case "percent":
+				await convertDeepnoteFileToPercentFiles(absolutePath, { outputDir });
+				break;
+			case "quarto":
+				await convertDeepnoteFileToQuartoFiles(absolutePath, { outputDir });
+				break;
+			case "marimo":
+				await convertDeepnoteFileToMarimoFiles(absolutePath, { outputDir });
+				break;
 		}
+		spinner.succeed(`${formatNames[outputFormat]} have been saved to ${chalk.bold(outputDir)}`);
+		return outputDir;
+	} catch (error) {
+		spinner.fail("Conversion failed");
+		throw error;
 	}
-	throw new Error("Unsupported file type. Please provide a .ipynb or .deepnote file.");
+}
+/** Check if file content is Marimo format */
+function isMarimoContent(content) {
+	return /^import marimo\b/m.test(content) && /@app\.cell\b/.test(content) && !/^\s*['"]{3}[\s\S]*?import marimo/m.test(content);
+}
+/** Check if file content is percent format */
+function isPercentContent(content) {
+	return /^# %%/m.test(content) && !/^\s*['"]{3}[\s\S]*?# %%/m.test(content);
 }
 
 //#endregion