doclific 0.1.0

package/frontend/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "files": [],
+  "references": [{ "path": "./tsconfig.app.json" }, { "path": "./tsconfig.node.json" }],
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  }
+}

package/frontend/tsconfig.node.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2023",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "types": ["node"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}

package/frontend/vite.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react-swc';
+import tailwindcss from '@tailwindcss/vite';
+import path from 'path';
+
+// https://vite.dev/config/
+export default defineConfig({
+	plugins: [react(), tailwindcss()],
+	resolve: {
+		alias: {
+			'@': path.resolve(__dirname, './src'),
+		},
+	},
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+	"name": "doclific",
+	"version": "0.1.0",
+	"type": "module",
+	"bin": {
+		"doclific": "./dist/bin/doclific.js"
+	},
+	"scripts": {
+		"build": "tsc",
+		"format": "prettier --write \"src/**/*.{ts,tsx,js,jsx,json}\"",
+		"format:check": "prettier --check \"src/**/*.{ts,tsx,js,jsx,json}\""
+	},
+	"dependencies": {
+		"@mdx-js/mdx": "^3.1.1",
+		"@orpc/client": "^1.12.2",
+		"@orpc/server": "^1.12.2",
+		"child_process": "^1.0.2",
+		"cors": "^2.8.5",
+		"express": "^5.2.1",
+		"util": "^0.12.5",
+		"zod": "^4.1.13"
+	},
+	"devDependencies": {
+		"@types/cors": "^2.8.19",
+		"@types/express": "^5.0.6",
+		"@types/node": "^20.6.0",
+		"prettier": "^3.7.4",
+		"typescript": "^5.4.5"
+	}
+}

package/src/bin/doclific.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { spawn } from 'child_process';
+import { startServer } from '../server/index.js';
+
+const port =
+	process.argv.find((arg) => arg.startsWith('-p=') || arg.startsWith('--port='))?.split('=')[1] ||
+	6767;
+
+const cwd = process.cwd();
+console.log('Doclific CLI running in directory:', cwd);
+
+startServer(Number(port));
+
+// Optional: open browser automatically
+const open =
+	process.platform === 'win32' ? 'start' : process.platform === 'darwin' ? 'open' : 'xdg-open';
+spawn(open, [`http://localhost:${port}`]);

package/src/core/codebase.ts

@@ -0,0 +1,39 @@
+import path from 'path';
+import fs from 'fs/promises';
+
+interface FileNode {
+	path: string;
+	name: string;
+	type: 'file' | 'directory';
+	children?: FileNode[];
+}
+
+/**
+ * Get all contents of a folder given a filePath.
+ * @param filePath - The relative path to the folder
+ */
+export const getFolderContents = async (filePath: string): Promise<FileNode[]> => {
+	const currentDir = process.cwd();
+	let fullPath = '';
+	if (filePath !== '') {
+		fullPath = path.join(currentDir, filePath);
+	} else {
+		fullPath = currentDir;
+	}
+	const entries = await fs.readdir(fullPath, { withFileTypes: true });
+	const nodes: FileNode[] = [];
+	for (const entry of entries) {
+		nodes.push({
+			path: path.join(filePath, entry.name),
+			name: entry.name,
+			type: entry.isDirectory() ? 'directory' : 'file',
+		});
+	}
+	return nodes;
+};
+
+export const getFileContents = async (filePath: string) => {
+	const currentDir = process.cwd();
+	const fullPath = path.join(currentDir, filePath);
+	return fs.readFile(fullPath, 'utf8');
+};

package/src/core/docs.ts

@@ -0,0 +1,90 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+type FolderStructure = {
+	name: string;
+	title: string;
+	icon?: string;
+	children: FolderStructure[];
+};
+
+const scanDirectory = async (dirPath: string): Promise<FolderStructure[]> => {
+	const entries = await fs.readdir(dirPath, { withFileTypes: true });
+	const folders: FolderStructure[] = [];
+
+	for (const entry of entries) {
+		if (entry.isDirectory()) {
+			const fullPath = path.join(dirPath, entry.name);
+			const children = await scanDirectory(fullPath);
+			let config: { title: string; icon: string | undefined } = {
+				title: entry.name,
+				icon: undefined,
+			};
+			// get the config.json file
+			const configPath = path.join(fullPath, 'config.json');
+			try {
+				const configFile = await fs.readFile(configPath, 'utf8');
+				config = JSON.parse(configFile);
+			} catch {
+				throw new Error(`Config file not found for ${entry.name}`);
+			}
+			folders.push({
+				name: entry.name,
+				title: config.title,
+				icon: config.icon,
+				children,
+			});
+		}
+	}
+
+	return folders;
+};
+
+export const getDocs = async (): Promise<FolderStructure[]> => {
+	const docsFolder = path.join(process.cwd(), 'doclific');
+	try {
+		await fs.access(docsFolder);
+	} catch {
+		return [];
+	}
+	return scanDirectory(docsFolder);
+};
+
+/**
+ * This function will return the content of the .mdx file in the directory with the given filePath.
+ * @param filePath - The path to the file
+ * @returns
+ */
+export const getDoc = async (filePath: string) => {
+	const currentDir = process.cwd();
+	const fullPath = path.join(currentDir, 'doclific', filePath);
+	try {
+		return fs.readFile(path.join(fullPath, 'content.mdx'), 'utf8');
+	} catch {
+		return undefined;
+	}
+};
+
+export const updateDoc = async (filePath: string, content: string) => {
+	const currentDir = process.cwd();
+	const fullPath = path.join(currentDir, 'doclific', filePath);
+	await fs.writeFile(path.join(fullPath, 'content.mdx'), content);
+};
+
+export const createDoc = async (filePath: string, title: string, icon: string | undefined) => {
+	const currentDir = process.cwd();
+	const fullPath = path.join(currentDir, 'doclific', filePath);
+
+	const newFolderName = crypto.randomUUID();
+	const newFolderPath = path.join(fullPath, newFolderName);
+	await fs.mkdir(newFolderPath, { recursive: true });
+	// create content.mdx file
+	await fs.writeFile(path.join(newFolderPath, 'content.mdx'), '# Hello World');
+	// create config.json file
+	await fs.writeFile(
+		path.join(newFolderPath, 'config.json'),
+		JSON.stringify({ title, icon }, null, 2)
+	);
+	// return the new folder path
+	return newFolderPath;
+};

package/src/core/git.ts

@@ -0,0 +1,48 @@
+import util from 'util';
+import { exec } from 'child_process';
+
+const execAsync = util.promisify(exec);
+
+export const getGitRepositoryName = async (): Promise<string | null> => {
+	try {
+		const GET_REPO_NAME_COMMAND = `git config --get remote.origin.url | sed -E "s|.*/(.+)\\.git|\\1|"`;
+		const repoName = await execAsync(GET_REPO_NAME_COMMAND);
+		return repoName.stdout.toString().trim();
+	} catch (error) {
+		console.error(error);
+		return null;
+	}
+};
+
+export const getGitRepositoryBranch = async (): Promise<string | null> => {
+	try {
+		const GET_REPO_BRANCH_COMMAND = `git rev-parse --abbrev-ref HEAD`;
+		const repoBranch = await execAsync(GET_REPO_BRANCH_COMMAND);
+		return repoBranch.stdout.toString().trim();
+	} catch (error) {
+		console.error(error);
+		return null;
+	}
+};
+
+export const getGitUser = async (): Promise<string | null> => {
+	try {
+		const GET_USER_COMMAND = `git config user.name`;
+		const user = await execAsync(GET_USER_COMMAND);
+		return user.stdout.toString().trim();
+	} catch (error) {
+		console.error(error);
+		return null;
+	}
+};
+
+export const getGitUserEmail = async (): Promise<string | null> => {
+	try {
+		const GET_USER_EMAIL_COMMAND = `git config user.email`;
+		const userEmail = await execAsync(GET_USER_EMAIL_COMMAND);
+		return userEmail.stdout.toString().trim();
+	} catch (error) {
+		console.error(error);
+		return null;
+	}
+};

package/src/server/index.ts

@@ -0,0 +1,55 @@
+import express from 'express';
+import cors from 'cors';
+import { RPCHandler } from '@orpc/server/node';
+import { onError } from '@orpc/server';
+import { router } from './router.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const frontendDist = path.join(__dirname, '../../frontend/dist');
+
+export function startServer(port: number = 6767) {
+	const app = express();
+
+	app.use(cors());
+
+	const handler = new RPCHandler(router, {
+		interceptors: [
+			onError((error) => {
+				console.error(error);
+			}),
+		],
+	});
+
+	app.use('/rpc{/*path}', async (req, res, next) => {
+		const { matched } = await handler.handle(req, res, {
+			prefix: '/rpc',
+			context: {},
+		});
+
+		if (matched) return;
+
+		next();
+	});
+
+	// serve static files in frontend/dist
+	app.use((req, res, next) => {
+		if (req.url === '/') {
+			const html = fs.readFileSync(path.join(frontendDist, 'index.html'), 'utf8');
+			res.send(html.replace(': BACKEND_PORT', `: ${port.toString()}`));
+		} else {
+			express.static(frontendDist)(req, res, next);
+		}
+	});
+
+	app.get('/{*splat}', (req, res) => {
+		const html = fs.readFileSync(path.join(frontendDist, 'index.html'), 'utf8');
+		res.send(html.replace(': BACKEND_PORT', `: ${port.toString()}`));
+	});
+
+	app.listen(port, () => console.log(`Access your documentation here: http://localhost:${port}`));
+}

package/src/server/router.ts

@@ -0,0 +1,65 @@
+import { os } from '@orpc/server';
+import {
+	getGitRepositoryBranch,
+	getGitRepositoryName,
+	getGitUser,
+	getGitUserEmail,
+} from '../core/git.js';
+import { createDoc, getDoc, getDocs, updateDoc } from '../core/docs.js';
+import { z } from 'zod';
+import { getFileContents, getFolderContents } from '../core/codebase.js';
+import path from 'path';
+
+export const router = {
+	git: {
+		getRepoInfo: os.handler(async () => {
+			return {
+				repositoryName: await getGitRepositoryName(),
+				repositoryBranch: await getGitRepositoryBranch(),
+				user: await getGitUser(),
+				userEmail: await getGitUserEmail(),
+			};
+		}),
+	},
+	docs: {
+		getDocs: os.handler(async () => {
+			return await getDocs();
+		}),
+		getDoc: os.input(z.object({ filePath: z.string() })).handler(async ({ input }) => {
+			const { filePath } = input;
+			return await getDoc(filePath);
+		}),
+		updateDoc: os
+			.input(z.object({ filePath: z.string(), content: z.string() }))
+			.handler(async ({ input }) => {
+				const { filePath, content } = input;
+				return await updateDoc(filePath, content);
+			}),
+		createDoc: os
+			.input(
+				z.object({ filePath: z.string(), title: z.string(), icon: z.string().optional() })
+			)
+			.handler(async ({ input }) => {
+				const { filePath, title, icon } = input;
+				return await createDoc(filePath, title, icon);
+			}),
+	},
+	codebase: {
+		getFolderContents: os
+			.input(z.object({ filePath: z.string() }))
+			.handler(async ({ input }) => {
+				const { filePath } = input;
+				return await getFolderContents(filePath);
+			}),
+		getFileContents: os.input(z.object({ filePath: z.string() })).handler(async ({ input }) => {
+			const { filePath } = input;
+			const currentDir = process.cwd();
+			return {
+				contents: await getFileContents(filePath),
+				fullPath: path.join(currentDir, '..', filePath),
+			};
+		}),
+	},
+};
+
+export type Router = typeof router;

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2020"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "types": ["node"]
+  },
+  "include": ["src"]
+}