repoburg 1.3.82 → 1.3.83

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "repoburg",
-  "version": "1.3.82",
+  "version": "1.3.83",
   "description": "A local AI-powered software developer assistant that runs on your own machine.",
   "author": "Celal Ertug",
   "license": "SEE LICENSE IN LICENSE",
@@ -65,6 +65,7 @@
     "dotenv": "^16.4.5",
     "eta": "^3.5.0",
     "express": "^4.19.2",
+    "form-data": "^4.0.0",
     "fs-extra": "^11.2.0",
     "glob": "^11.1.0",
     "google-auth-library": "^9.11.0",

package/platform-cli.js

@@ -378,4 +378,143 @@ program
         }
     });
 
+/**
+ * Resolves backend port from instance name or current working directory.
+ * @param {string|undefined} instanceName - Optional instance name
+ * @returns {Promise<number>} - Backend port
+ */
+const resolveBackendPort = async (instanceName) => {
+    const { default: chalk } = await import('chalk');
+    
+    const servicesResponse = await axios.get(`${DAEMON_BASE_URL}/services`);
+    const services = servicesResponse.data;
+
+    if (!services || services.length === 0) {
+        console.error(chalk.red('No backend services found.'));
+        console.error(chalk.yellow('Start a service first with `repoburg start`.'));
+        process.exit(1);
+    }
+
+    let service;
+    if (instanceName) {
+        service = services.find(s => s.name === instanceName);
+        if (!service) {
+            console.error(chalk.red(`Instance '${instanceName}' not found.`));
+            console.error(chalk.yellow('Available instances:'));
+            services.forEach(s => console.error(chalk.gray(`  - ${s.name} (${s.status}, port ${s.port})`)));
+            process.exit(1);
+        }
+    } else {
+        const cwd = process.cwd();
+        service = services.find(s => s.status === 'running' && cwd.startsWith(s.path));
+        if (!service) {
+            console.error(chalk.red('No running backend service found for current directory.'));
+            console.error(chalk.yellow(`Current directory: ${cwd}`));
+            console.error(chalk.yellow('Running services:'));
+            services.filter(s => s.status === 'running').forEach(s => {
+                console.error(chalk.gray(`  - ${s.name} (path: ${s.path}, port ${s.port})`));
+            });
+            process.exit(1);
+        }
+    }
+
+    if (service.status !== 'running') {
+        console.error(chalk.red(`Instance '${service.name}' is not running (status: ${service.status}).`));
+        process.exit(1);
+    }
+
+    console.log(chalk.gray(`Using instance '${service.name}' on port ${service.port}`));
+    return service.port;
+};
+
+program
+    .command('export [sessionId] [path]')
+    .description('Export a session to a JSON file. Uses active session if sessionId not provided.')
+    .option('-i, --instance <name>', 'Backend instance name')
+    .action(async (sessionId, exportPath, options) => {
+        const { default: chalk } = await import('chalk');
+        try {
+            const backendPort = await resolveBackendPort(options.instance);
+
+            // If sessionId not provided, get active session
+            let targetSessionId = sessionId;
+            if (!targetSessionId) {
+                const activeResponse = await axios.get(`http://localhost:${backendPort}/sessions/active`);
+                if (activeResponse.status === 204 || !activeResponse.data) {
+                    console.error(chalk.red('No active session found.'));
+                    console.error(chalk.yellow('Specify a session ID or activate a session first.'));
+                    process.exit(1);
+                }
+                targetSessionId = activeResponse.data.id;
+                console.log(chalk.gray(`Using active session: ${targetSessionId}`));
+            }
+
+            // Determine export path
+            const finalPath = exportPath || `./session-export-${targetSessionId}.json`;
+            const resolvedPath = path.resolve(finalPath);
+
+            // Export session (get raw text, don't let axios parse JSON)
+            const exportResponse = await axios.get(
+                `http://localhost:${backendPort}/sessions/${targetSessionId}/export`,
+                { responseType: 'text' }
+            );
+            
+            // Write to file directly
+            await fs.writeFile(resolvedPath, exportResponse.data);
+            console.log(chalk.green(`✓ Session exported to: ${resolvedPath}`));
+
+        } catch (error) {
+            handleApiError(error);
+        }
+    });
+
+program
+    .command('import <path>')
+    .description('Import a session from a JSON file.')
+    .option('-i, --instance <name>', 'Backend instance name')
+    .option('-n, --name <name>', 'Name for the imported session (not yet supported)')
+    .action(async (importPath, options) => {
+        const { default: chalk } = await import('chalk');
+        try {
+            const backendPort = await resolveBackendPort(options.instance);
+
+            // Resolve and read the file
+            const resolvedPath = path.resolve(importPath);
+            console.log(chalk.gray(`Reading file: ${resolvedPath}`));
+            
+            const fileContent = await fs.readFile(resolvedPath, 'utf-8');
+            
+            // Parse to validate JSON
+            let sessionData;
+            try {
+                sessionData = JSON.parse(fileContent);
+            } catch (e) {
+                console.error(chalk.red('Invalid JSON file.'));
+                process.exit(1);
+            }
+
+            // Import session via API
+            const FormData = require('form-data');
+            const form = new FormData();
+            form.append('file', fileContent, {
+                filename: path.basename(resolvedPath),
+                contentType: 'application/json',
+            });
+
+            const importResponse = await axios.post(
+                `http://localhost:${backendPort}/sessions/import`,
+                form,
+                { headers: form.getHeaders() }
+            );
+
+            const { session_id, message_count } = importResponse.data;
+            console.log(chalk.green(`✓ Session imported successfully!`));
+            console.log(chalk.cyan(`  Session ID: ${session_id}`));
+            console.log(chalk.cyan(`  Messages: ${message_count}`));
+
+        } catch (error) {
+            handleApiError(error);
+        }
+    });
+
 program.parse(process.argv);