@pierre/storage 0.3.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pierre/storage",
-	"version": "0.3.0",
+	"version": "0.4.1",
 	"description": "Pierre Git Storage SDK",
 	"license": "MIT",
 	"type": "module",

package/src/index.ts

@@ -15,6 +15,7 @@ import {
 	branchDiffResponseSchema,
 	commitDiffResponseSchema,
 	createBranchResponseSchema,
+	grepResponseSchema,
 	listBranchesResponseSchema,
 	listCommitsResponseSchema,
 	listFilesResponseSchema,
@@ -32,6 +33,8 @@ import type {
 	CreateCommitFromDiffOptions,
 	CreateCommitOptions,
 	CreateRepoOptions,
+	DeleteRepoOptions,
+	DeleteRepoResult,
 	DiffFileState,
 	FileDiff,
 	FilteredFile,
@@ -45,6 +48,10 @@ import type {
 	GetFileOptions,
 	GetRemoteURLOptions,
 	GitStorageOptions,
+	GrepFileMatch,
+	GrepLine,
+	GrepOptions,
+	GrepResult,
 	ListBranchesOptions,
 	ListBranchesResponse,
 	ListBranchesResult,
@@ -330,6 +337,24 @@ function transformCreateBranchResult(raw: CreateBranchResponse): CreateBranchRes
 	};
 }
 
+function transformGrepLine(raw: { line_number: number; text: string; type: string }): GrepLine {
+	return {
+		lineNumber: raw.line_number,
+		text: raw.text,
+		type: raw.type,
+	};
+}
+
+function transformGrepFileMatch(raw: {
+	path: string;
+	lines: { line_number: number; text: string; type: string }[];
+}): GrepFileMatch {
+	return {
+		path: raw.path,
+		lines: raw.lines.map(transformGrepLine),
+	};
+}
+
 /**
  * Implementation of the Repo interface
  */
@@ -522,6 +547,91 @@ class RepoImpl implements Repo {
 		return transformCommitDiffResult(raw);
 	}
 
+	async grep(options: GrepOptions): Promise<GrepResult> {
+		const pattern = options?.query?.pattern?.trim();
+		if (!pattern) {
+			throw new Error('grep query.pattern is required');
+		}
+
+		const ttl = resolveInvocationTtlSeconds(options, DEFAULT_TOKEN_TTL_SECONDS);
+		const jwt = await this.generateJWT(this.id, {
+			permissions: ['git:read'],
+			ttl,
+		});
+
+		const body: Record<string, unknown> = {
+			query: {
+				pattern,
+				...(typeof options.query.caseSensitive === 'boolean'
+					? { case_sensitive: options.query.caseSensitive }
+					: {}),
+			},
+		};
+
+		if (options.ref) {
+			body.rev = options.ref;
+		}
+		if (Array.isArray(options.paths) && options.paths.length > 0) {
+			body.paths = options.paths;
+		}
+		if (options.fileFilters) {
+			body.file_filters = {
+				...(options.fileFilters.includeGlobs
+					? { include_globs: options.fileFilters.includeGlobs }
+					: {}),
+				...(options.fileFilters.excludeGlobs
+					? { exclude_globs: options.fileFilters.excludeGlobs }
+					: {}),
+				...(options.fileFilters.extensionFilters
+					? { extension_filters: options.fileFilters.extensionFilters }
+					: {}),
+			};
+		}
+		if (options.context) {
+			body.context = {
+				...(typeof options.context.before === 'number' ? { before: options.context.before } : {}),
+				...(typeof options.context.after === 'number' ? { after: options.context.after } : {}),
+			};
+		}
+		if (options.limits) {
+			body.limits = {
+				...(typeof options.limits.maxLines === 'number'
+					? { max_lines: options.limits.maxLines }
+					: {}),
+				...(typeof options.limits.maxMatchesPerFile === 'number'
+					? { max_matches_per_file: options.limits.maxMatchesPerFile }
+					: {}),
+			};
+		}
+		if (options.pagination) {
+			body.pagination = {
+				...(typeof options.pagination.cursor === 'string' && options.pagination.cursor.trim() !== ''
+					? { cursor: options.pagination.cursor }
+					: {}),
+				...(typeof options.pagination.limit === 'number'
+					? { limit: options.pagination.limit }
+					: {}),
+			};
+		}
+
+		const response = await this.api.post({ path: 'repos/grep', body }, jwt);
+		const raw = grepResponseSchema.parse(await response.json());
+
+		return {
+			query: {
+				pattern: raw.query.pattern,
+				caseSensitive: raw.query.case_sensitive,
+			},
+			repo: {
+				ref: raw.repo.ref,
+				commit: raw.repo.commit,
+			},
+			matches: raw.matches.map(transformGrepFileMatch),
+			nextCursor: raw.next_cursor ?? undefined,
+			hasMore: raw.has_more,
+		};
+	}
+
 	async pullUpstream(options: PullUpstreamOptions = {}): Promise<void> {
 		const ttl = resolveInvocationTtlSeconds(options, DEFAULT_TOKEN_TTL_SECONDS);
 		const jwt = await this.generateJWT(this.id, {
@@ -820,6 +930,34 @@ export class GitStorage {
 		return new RepoImpl(options.id, this.options, this.generateJWT.bind(this));
 	}
 
+	/**
+	 * Delete a repository by ID
+	 * @param options The delete options containing the repo ID
+	 * @returns The deletion result
+	 */
+	async deleteRepo(options: DeleteRepoOptions): Promise<DeleteRepoResult> {
+		const ttl = resolveInvocationTtlSeconds(options, DEFAULT_TOKEN_TTL_SECONDS);
+		const jwt = await this.generateJWT(options.id, {
+			permissions: ['repo:write'],
+			ttl,
+		});
+
+		// Allow 404 and 409 for clearer error handling
+		const resp = await this.api.delete('repos/delete', jwt, { allowedStatus: [404, 409] });
+		if (resp.status === 404) {
+			throw new Error('Repository not found');
+		}
+		if (resp.status === 409) {
+			throw new Error('Repository already deleted');
+		}
+
+		const body = (await resp.json()) as { repo_id: string; message: string };
+		return {
+			repoId: body.repo_id,
+			message: body.message,
+		};
+	}
+
 	/**
 	 * Get the current configuration
 	 * @returns The client configuration

package/src/schemas.ts

@@ -128,6 +128,31 @@ export const restoreCommitResponseSchema = z.object({
 	result: refUpdateResultWithOptionalsSchema,
 });
 
+export const grepLineSchema = z.object({
+	line_number: z.number(),
+	text: z.string(),
+	type: z.string(),
+});
+
+export const grepFileMatchSchema = z.object({
+	path: z.string(),
+	lines: z.array(grepLineSchema),
+});
+
+export const grepResponseSchema = z.object({
+	query: z.object({
+		pattern: z.string(),
+		case_sensitive: z.boolean(),
+	}),
+	repo: z.object({
+		ref: z.string(),
+		commit: z.string(),
+	}),
+	matches: z.array(grepFileMatchSchema),
+	next_cursor: z.string().nullable().optional(),
+	has_more: z.boolean(),
+});
+
 export const errorEnvelopeSchema = z.object({
 	error: z.string(),
 });
@@ -144,3 +169,4 @@ export type GetCommitDiffResponseRaw = z.infer<typeof commitDiffResponseSchema>;
 export type CreateBranchResponseRaw = z.infer<typeof createBranchResponseSchema>;
 export type CommitPackAckRaw = z.infer<typeof commitPackAckSchema>;
 export type RestoreCommitAckRaw = z.infer<typeof restoreCommitAckSchema>;
+export type GrepResponseRaw = z.infer<typeof grepResponseSchema>;

package/src/types.ts

@@ -46,6 +46,7 @@ export interface Repo {
 	listCommits(options?: ListCommitsOptions): Promise<ListCommitsResult>;
 	getBranchDiff(options: GetBranchDiffOptions): Promise<GetBranchDiffResult>;
 	getCommitDiff(options: GetCommitDiffOptions): Promise<GetCommitDiffResult>;
+	grep(options: GrepOptions): Promise<GrepResult>;
 	pullUpstream(options?: PullUpstreamOptions): Promise<void>;
 	restoreCommit(options: RestoreCommitOptions): Promise<RestoreCommitResult>;
 	createBranch(options: CreateBranchOptions): Promise<CreateBranchResult>;
@@ -88,6 +89,15 @@ export interface CreateRepoOptions extends GitStorageInvocationOptions {
 	defaultBranch?: string;
 }
 
+export interface DeleteRepoOptions extends GitStorageInvocationOptions {
+	id: string;
+}
+
+export interface DeleteRepoResult {
+	repoId: string;
+	message: string;
+}
+
 // Get File API types
 export interface GetFileOptions extends GitStorageInvocationOptions {
 	path: string;
@@ -214,6 +224,62 @@ export interface GetCommitDiffResult {
 	filteredFiles: FilteredFile[];
 }
 
+// Grep API types
+export interface GrepOptions extends GitStorageInvocationOptions {
+	ref?: string;
+	paths?: string[];
+	query: {
+		pattern: string;
+		/**
+		 * Default is case-sensitive.
+		 * When omitted, the server default is used.
+		 */
+		caseSensitive?: boolean;
+	};
+	fileFilters?: {
+		includeGlobs?: string[];
+		excludeGlobs?: string[];
+		extensionFilters?: string[];
+	};
+	context?: {
+		before?: number;
+		after?: number;
+	};
+	limits?: {
+		maxLines?: number;
+		maxMatchesPerFile?: number;
+	};
+	pagination?: {
+		cursor?: string;
+		limit?: number;
+	};
+}
+
+export interface GrepLine {
+	lineNumber: number;
+	text: string;
+	type: string;
+}
+
+export interface GrepFileMatch {
+	path: string;
+	lines: GrepLine[];
+}
+
+export interface GrepResult {
+	query: {
+		pattern: string;
+		caseSensitive: boolean;
+	};
+	repo: {
+		ref: string;
+		commit: string;
+	};
+	matches: GrepFileMatch[];
+	nextCursor?: string;
+	hasMore: boolean;
+}
+
 // Shared diff types
 export interface DiffStats {
 	files: number;