🚧 WIP

codemod.ts

@@ -0,0 +1,176 @@
+// @deno-types="npm:@types/jscodeshift"
+import {
+    API,
+    ASTPath,
+    CallExpression,
+    FileInfo,
+    ImportSpecifier,
+    ObjectExpression
+} from "npm:jscodeshift";
+
+let DIARY_LEVELS = ["debug", "log", "info", "warn", "error", "fatal"];
+
+export default function transform(file: FileInfo, api: API, options: any) {
+	let j = api.jscodeshift;
+	let root = j(file.source);
+
+	let diary_imports = root.find(j.ImportDeclaration, {
+		source: {
+			type: "Literal",
+			value: "diary",
+		},
+	});
+
+	let log_ident = j.identifier("log");
+
+	for (let path of diary_imports.paths()) {
+		let specifiers = path.node.specifiers!;
+
+		for (let specifier of specifiers) {
+			if (specifier.type !== "ImportSpecifier") continue;
+
+			if (DIARY_LEVELS.includes(specifier.imported.name)) {
+				process_level_import(specifier);
+			}
+		}
+	}
+
+    diary_imports.at(-1).insertBefore(
+        j.template.statements`
+        import { diary } from 'diary';
+        import { plain } from 'diary/output.console';
+        `
+    );
+
+    diary_imports.remove();
+
+	let body_start = root.find(j.ImportDeclaration).at(-1);
+
+	body_start.insertAfter(j.template.statement`const ${log_ident} = diary(plain);`);
+
+	return root.toSource();
+
+	// ---
+
+	function process_level_import(specifier: ImportSpecifier) {
+		let level = specifier.imported.name;
+
+		let log_callers = root.find(j.CallExpression, {
+			callee: {
+				name: specifier.local?.name ?? specifier.imported.name,
+				type: "Identifier",
+			},
+		});
+
+		for (let log_caller of log_callers.paths()) {
+			create_diary_call(log_caller, level);
+		}
+	}
+
+	function create_diary_call(path: ASTPath<CallExpression>, level: string) {
+		let args = path.node.arguments;
+		path.node.callee = log_ident;
+
+		if (args.length === 1) {
+			if (
+				args[0].type === "NewExpression" &&
+				args[0].callee.type === "Identifier" &&
+				args[0].callee.name === "Error"
+			) {
+				path.node.arguments = [
+					j.literal(level),
+					j.literal("{error}"),
+					j.template.statement`{error: ${args[0]}}`,
+				];
+			} else if (args[0].type === "Identifier") {
+				path.node.arguments = [j.literal(level), j.literal("{message}"), args[0]];
+			} else {
+				path.node.arguments = [j.literal(level), ...args];
+			}
+		} else {
+			let [message, ...props] = args;
+			if (message.type !== "Literal")
+				throw new Error("Message must be a literal");
+
+			let new_message = j.stringLiteral("");
+			let new_props = j.objectExpression.from({
+				properties: [],
+			});
+
+			let segs = (message.value as string).split(/\%([oOifs])/g);
+			for (var i = 0; i < segs.length; i += 2) {
+				let s = segs[i];
+				new_message.value += s;
+
+				if (i === segs.length - 1) break;
+				let prop_index = i / 2;
+				let prop = props[prop_index];
+
+				let name = diary_set_log_member_object(
+					new_props,
+					prop,
+					prop_index
+				);
+				new_message.value += `{${name}}`;
+			}
+
+			for (let j = i / 2; j < props.length; j++) {
+				let prop = props[j];
+				diary_set_log_member_object(new_props, prop, j);
+			}
+
+			let all_numbers = new_props.properties.every((p) => {
+				if (p.type !== "ObjectProperty") return false;
+				if (p.key.type !== "Literal") return false;
+
+				return typeof p.key.value == "number";
+			});
+
+			if (all_numbers) {
+				new_props = j.arrayExpression(
+					new_props.properties.map((p) => {
+						return p.value;
+					})
+				);
+			}
+
+			path.node.arguments = [j.literal(level), new_message, new_props];
+		}
+	}
+
+	function diary_set_log_member_object(
+		target: ObjectExpression,
+		prop: any,
+		props_index: number
+	) {
+        if (prop.type === 'SpreadElement') {
+            throw new Error('Spread elements are not supported');
+        }
+
+		switch (prop.type) {
+			case "Identifier": {
+				target.properties.push(
+					j.objectProperty.from({
+						key: prop,
+						value: prop,
+						shorthand: true,
+					})
+				);
+				return prop.name;
+			}
+			default:
+				target.properties.push(
+					j.objectProperty(j.literal(props_index), prop)
+				);
+				return String(props_index);
+		}
+	}
+}
+
+function find_parent<T>(node: ASTPath<any>, type: T): T | undefined {
+    console.log(node, type);
+	if (!node.parent) return undefined;
+	if (node.parent.type === type) return node.parent;
+
+	return find_parent(node.parent, type);
+}

codemod/test.ts

@@ -0,0 +1,32 @@
+import { info } from 'diary';
+import { fatal, warn } from 'diary';
+import x from 'y';
+
+let user = { name: 'John' };
+
+info('Hello, world!');
+info('Hello %s', 'world');
+info('Hello %o', { world: true });
+info('Hello %o', user);
+info('Hello %o for %o', user, user);
+
+info('Hello %s with %s', 'world', 'extra', 'props');
+
+function scope_example() {
+    info('Hello %s %o', 'world', {
+        user,
+        user1: { name: 'John3' }, 
+    });
+}
+
+fatal(new Error());
+
+try {} catch(e) {
+    fatal(e)
+}
+
+let errors = ['a', 'b']
+
+warn('something bad', ...errors)
+warn('something bad %s', ...errors);
+warn('something bad %s', ...['a', 'b'])