@ottocode/server 0.1.272 → 0.1.273

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/server",
-	"version": "0.1.272",
+	"version": "0.1.273",
 	"description": "HTTP API server for ottocode",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -61,8 +61,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@ottocode/database": "0.1.272",
-		"@ottocode/sdk": "0.1.272",
+		"@ottocode/database": "0.1.273",
+		"@ottocode/sdk": "0.1.273",
 		"@hono/zod-openapi": "^1.1.5",
 		"ai-sdk-ollama": "^3.8.3",
 		"drizzle-orm": "^0.44.5",

package/src/openapi/schemas.ts

@@ -267,6 +267,13 @@ export const schemas = {
 		type: 'object',
 		properties: {
 			branch: { type: 'string' },
+			headSha: { type: 'string' },
+			shortHeadSha: { type: 'string' },
+			isDetached: { type: 'boolean' },
+			operation: {
+				$ref: '#/components/schemas/GitOperation',
+				nullable: true,
+			},
 			ahead: { type: 'integer' },
 			behind: { type: 'integer' },
 			staged: {
@@ -295,6 +302,10 @@ export const schemas = {
 		},
 		required: [
 			'branch',
+			'headSha',
+			'shortHeadSha',
+			'isDetached',
+			'operation',
 			'ahead',
 			'behind',
 			'staged',
@@ -307,6 +318,28 @@ export const schemas = {
 			'remotes',
 		],
 	},
+	GitOperation: {
+		type: 'object',
+		properties: {
+			type: {
+				type: 'string',
+				enum: [
+					'rebase',
+					'rebase-interactive',
+					'merge',
+					'cherry-pick',
+					'revert',
+					'bisect',
+				],
+			},
+			label: { type: 'string' },
+			current: { type: 'integer' },
+			total: { type: 'integer' },
+			headName: { type: 'string' },
+			onto: { type: 'string' },
+		},
+		required: ['type', 'label'],
+	},
 	GitFile: {
 		type: 'object',
 		properties: {

package/src/routes/git/index.ts

@@ -6,6 +6,7 @@ import { registerStagingRoutes } from './staging.ts';
 import { registerCommitRoutes } from './commit.ts';
 import { registerPushRoute } from './push.ts';
 import { registerPullRoute } from './pull.ts';
+import { registerRebaseRoute } from './rebase.ts';
 import { registerInitRoute } from './init.ts';
 import { registerRemoteRoutes } from './remote.ts';
 
@@ -19,6 +20,7 @@ export function registerGitRoutes(app: Hono) {
 	registerCommitRoutes(app);
 	registerPushRoute(app);
 	registerPullRoute(app);
+	registerRebaseRoute(app);
 	registerInitRoute(app);
 	registerRemoteRoutes(app);
 }

package/src/routes/git/init.ts

@@ -1,7 +1,10 @@
 import type { Hono } from 'hono';
 import { execFile } from 'node:child_process';
+import { realpath, stat } from 'node:fs/promises';
+import { resolve } from 'node:path';
 import { promisify } from 'node:util';
 import { gitStatusSchema } from './schemas.ts';
+import { validateAndGetGitRoot } from './utils.ts';
 import { openApiRoute } from '../../openapi/route.ts';
 
 const execFileAsync = promisify(execFile);
@@ -89,7 +92,27 @@ export function registerInitRoute(app: Hono) {
 			try {
 				const body = await c.req.json().catch(() => ({}));
 				const { project } = gitStatusSchema.parse(body);
-				const requestedPath = project || process.cwd();
+				const requestedPath = await realpath(resolve(project || process.cwd()));
+
+				const pathStats = await stat(requestedPath);
+				if (!pathStats.isDirectory()) {
+					return c.json(
+						{
+							status: 'error',
+							error: 'Git repository can only be initialized in a directory',
+							code: 'NOT_A_DIRECTORY',
+						},
+						400,
+					);
+				}
+
+				const existing = await validateAndGetGitRoot(requestedPath);
+				if (!('error' in existing)) {
+					return c.json({
+						status: 'ok',
+						data: { initialized: false, path: existing.gitRoot },
+					});
+				}
 
 				await execFileAsync('git', ['init'], { cwd: requestedPath });
 

package/src/routes/git/rebase.ts

@@ -0,0 +1,178 @@
+import type { Hono } from 'hono';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { gitRebaseSchema } from './schemas.ts';
+import { getGitOperationState, validateAndGetGitRoot } from './utils.ts';
+import { openApiRoute } from '../../openapi/route.ts';
+
+const execFileAsync = promisify(execFile);
+
+const REBASE_ACTION_ARGS = {
+	continue: '--continue',
+	abort: '--abort',
+	skip: '--skip',
+} as const;
+
+export function registerRebaseRoute(app: Hono) {
+	openApiRoute(
+		app,
+		{
+			method: 'post',
+			path: '/v1/git/rebase',
+			tags: ['git'],
+			operationId: 'performGitRebaseAction',
+			summary: 'Perform a git rebase action',
+			description:
+				'Runs git rebase --continue, --abort, or --skip for an in-progress rebase.',
+			requestBody: {
+				required: true,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							properties: {
+								project: { type: 'string' },
+								action: {
+									type: 'string',
+									enum: ['continue', 'abort', 'skip'],
+								},
+							},
+							required: ['action'],
+						},
+					},
+				},
+			},
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									status: { type: 'string', enum: ['ok'] },
+									data: {
+										type: 'object',
+										properties: {
+											action: {
+												type: 'string',
+												enum: ['continue', 'abort', 'skip'],
+											},
+											output: { type: 'string' },
+										},
+										required: ['action', 'output'],
+									},
+								},
+								required: ['status', 'data'],
+							},
+						},
+					},
+				},
+				'400': {
+					description: 'Error',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									status: { type: 'string', enum: ['error'] },
+									error: { type: 'string' },
+									code: { type: 'string' },
+								},
+								required: ['status', 'error'],
+							},
+						},
+					},
+				},
+				'409': {
+					description: 'No rebase is currently in progress',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									status: { type: 'string', enum: ['error'] },
+									error: { type: 'string' },
+									code: { type: 'string' },
+								},
+								required: ['status', 'error'],
+							},
+						},
+					},
+				},
+				'500': {
+					description: 'Error',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									status: { type: 'string', enum: ['error'] },
+									error: { type: 'string' },
+									code: { type: 'string' },
+								},
+								required: ['status', 'error'],
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			try {
+				const body = await c.req.json().catch(() => ({}));
+				const { project, action } = gitRebaseSchema.parse(body);
+				const requestedPath = project || process.cwd();
+
+				const validation = await validateAndGetGitRoot(requestedPath);
+				if ('error' in validation) {
+					return c.json(
+						{ status: 'error', error: validation.error, code: validation.code },
+						400,
+					);
+				}
+
+				const operation = await getGitOperationState(validation.gitRoot);
+				if (!operation?.type.startsWith('rebase')) {
+					return c.json(
+						{
+							status: 'error',
+							error: 'No rebase is currently in progress',
+							code: 'NO_REBASE_IN_PROGRESS',
+						},
+						409,
+					);
+				}
+
+				const { stdout, stderr } = await execFileAsync(
+					'git',
+					['rebase', REBASE_ACTION_ARGS[action]],
+					{
+						cwd: validation.gitRoot,
+						env: {
+							...process.env,
+							GIT_EDITOR: 'true',
+							GIT_SEQUENCE_EDITOR: 'true',
+						},
+					},
+				);
+
+				return c.json({
+					status: 'ok',
+					data: { action, output: `${stdout}${stderr}`.trim() },
+				});
+			} catch (error) {
+				return c.json(
+					{
+						status: 'error',
+						error:
+							error instanceof Error
+								? error.message
+								: 'Failed to perform rebase action',
+					},
+					500,
+				);
+			}
+		},
+	);
+}

package/src/routes/git/schemas.ts

@@ -51,6 +51,11 @@ export const gitPullSchema = z.object({
 	project: z.string().optional(),
 });
 
+export const gitRebaseSchema = z.object({
+	project: z.string().optional(),
+	action: z.enum(['continue', 'abort', 'skip']),
+});
+
 export const gitRemoteAddSchema = z.object({
 	project: z.string().optional(),
 	name: z.string().min(1),

package/src/routes/git/staging-service.ts

@@ -24,7 +24,10 @@ const actionConfig: Record<
 > = {
 	stage: {
 		schema: gitStageSchema,
-		command: (files) => ['add', ...files],
+		command: (files) =>
+			files.length === 1 && files[0] === '.'
+				? ['add', '-A']
+				: ['add', '--', ...files],
 		dataKey: 'staged',
 		fallbackError: 'Failed to stage files',
 	},

package/src/routes/git/status.ts

@@ -6,7 +6,8 @@ import {
 	validateAndGetGitRoot,
 	parseGitStatus,
 	getAheadBehind,
-	getCurrentBranch,
+	getHeadInfo,
+	getGitOperationState,
 } from './utils.ts';
 import { openApiRoute } from '../../openapi/route.ts';
 
@@ -133,9 +134,11 @@ export function registerStatusRoute(app: Hono) {
 					gitRoot,
 				);
 
-				const { ahead, behind } = await getAheadBehind(gitRoot);
-
-				const branch = await getCurrentBranch(gitRoot);
+				const [{ ahead, behind }, headInfo, operation] = await Promise.all([
+					getAheadBehind(gitRoot),
+					getHeadInfo(gitRoot),
+					getGitOperationState(gitRoot),
+				]);
 
 				let hasUpstream = false;
 				try {
@@ -168,7 +171,11 @@ export function registerStatusRoute(app: Hono) {
 				return c.json({
 					status: 'ok',
 					data: {
-						branch,
+						branch: headInfo.branch,
+						headSha: headInfo.headSha,
+						shortHeadSha: headInfo.shortHeadSha,
+						isDetached: headInfo.isDetached,
+						operation,
 						ahead,
 						behind,
 						hasUpstream,

package/src/routes/git/types.ts

@@ -21,6 +21,23 @@ export interface GitFile {
 		| 'both-deleted';
 }
 
+export type GitOperationType =
+	| 'rebase'
+	| 'rebase-interactive'
+	| 'merge'
+	| 'cherry-pick'
+	| 'revert'
+	| 'bisect';
+
+export interface GitOperationState {
+	type: GitOperationType;
+	label: string;
+	current?: number;
+	total?: number;
+	headName?: string;
+	onto?: string;
+}
+
 export interface GitRoot {
 	gitRoot: string;
 }

package/src/routes/git/utils.ts

@@ -1,7 +1,8 @@
 import { execFile } from 'node:child_process';
-import { extname, join } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { extname, isAbsolute, join } from 'node:path';
 import { promisify } from 'node:util';
-import type { GitFile, GitRoot, GitError } from './types.ts';
+import type { GitFile, GitRoot, GitError, GitOperationState } from './types.ts';
 
 const execFileAsync = promisify(execFile);
 
@@ -163,7 +164,9 @@ export function parseGitStatus(
 			const xy = parts[1];
 			const x = xy[0];
 			const y = xy[1];
-			const path = parts.slice(8).join(' ');
+			const pathStartIndex = line.startsWith('2 ') ? 9 : 8;
+			const rawPath = parts.slice(pathStartIndex).join(' ');
+			const [path, oldPath] = rawPath.split('\t');
 			const absPath = join(gitRoot, path);
 
 			if (x !== '.') {
@@ -173,6 +176,7 @@ export function parseGitStatus(
 					status: getStatusFromCodeV2(x),
 					staged: true,
 					isNew: x === 'A',
+					oldPath,
 				});
 			}
 
@@ -183,6 +187,7 @@ export function parseGitStatus(
 					status: getStatusFromCodeV2(y),
 					staged: false,
 					isNew: false,
+					oldPath,
 				});
 			}
 		} else if (line.startsWith('? ')) {
@@ -247,3 +252,98 @@ export async function getCurrentBranch(gitRoot: string): Promise<string> {
 		return 'unknown';
 	}
 }
+
+export async function getHeadInfo(gitRoot: string): Promise<{
+	branch: string;
+	headSha: string;
+	shortHeadSha: string;
+	isDetached: boolean;
+}> {
+	const [branchResult, headResult, shortHeadResult] = await Promise.allSettled([
+		execFileAsync('git', ['branch', '--show-current'], { cwd: gitRoot }),
+		execFileAsync('git', ['rev-parse', 'HEAD'], { cwd: gitRoot }),
+		execFileAsync('git', ['rev-parse', '--short', 'HEAD'], { cwd: gitRoot }),
+	]);
+
+	const branch =
+		branchResult.status === 'fulfilled' ? branchResult.value.stdout.trim() : '';
+	const headSha =
+		headResult.status === 'fulfilled' ? headResult.value.stdout.trim() : '';
+	const shortHeadSha =
+		shortHeadResult.status === 'fulfilled'
+			? shortHeadResult.value.stdout.trim()
+			: headSha.slice(0, 7);
+
+	return {
+		branch: branch || 'HEAD',
+		headSha,
+		shortHeadSha,
+		isDetached: !branch,
+	};
+}
+
+async function getGitDir(gitRoot: string): Promise<string | null> {
+	try {
+		const { stdout } = await execFileAsync('git', ['rev-parse', '--git-dir'], {
+			cwd: gitRoot,
+		});
+		const gitDir = stdout.trim();
+		return isAbsolute(gitDir) ? gitDir : join(gitRoot, gitDir);
+	} catch {
+		return null;
+	}
+}
+
+function readGitStateFile(dir: string, file: string): string | undefined {
+	const path = join(dir, file);
+	if (!existsSync(path)) return undefined;
+	return readFileSync(path, 'utf8').trim() || undefined;
+}
+
+function readRebaseState(
+	gitDir: string,
+	dirName: 'rebase-merge' | 'rebase-apply',
+): GitOperationState | null {
+	const rebaseDir = join(gitDir, dirName);
+	if (!existsSync(rebaseDir)) return null;
+
+	const current = Number(readGitStateFile(rebaseDir, 'msgnum')) || undefined;
+	const total = Number(readGitStateFile(rebaseDir, 'end')) || undefined;
+	const isInteractive = existsSync(join(rebaseDir, 'interactive'));
+
+	return {
+		type: isInteractive ? 'rebase-interactive' : 'rebase',
+		label: isInteractive ? 'Interactive rebase' : 'Rebase',
+		current,
+		total,
+		headName: readGitStateFile(rebaseDir, 'head-name'),
+		onto: readGitStateFile(rebaseDir, 'onto'),
+	};
+}
+
+export async function getGitOperationState(
+	gitRoot: string,
+): Promise<GitOperationState | null> {
+	const gitDir = await getGitDir(gitRoot);
+	if (!gitDir) return null;
+
+	const rebaseState =
+		readRebaseState(gitDir, 'rebase-merge') ??
+		readRebaseState(gitDir, 'rebase-apply');
+	if (rebaseState) return rebaseState;
+
+	if (existsSync(join(gitDir, 'MERGE_HEAD'))) {
+		return { type: 'merge', label: 'Merge' };
+	}
+	if (existsSync(join(gitDir, 'CHERRY_PICK_HEAD'))) {
+		return { type: 'cherry-pick', label: 'Cherry-pick' };
+	}
+	if (existsSync(join(gitDir, 'REVERT_HEAD'))) {
+		return { type: 'revert', label: 'Revert' };
+	}
+	if (existsSync(join(gitDir, 'BISECT_LOG'))) {
+		return { type: 'bisect', label: 'Bisect' };
+	}
+
+	return null;
+}