gitx.do 0.0.3 → 0.1.1

package/dist/refs/tag.js

@@ -32,6 +32,8 @@
  * const versions = await listTags(manager, { pattern: 'v*' })
  * ```
  */
+// Re-export RefStorage for backward compatibility
+export { RefStorage } from './storage';
 /**
  * Error thrown when a tag operation fails.
  *
@@ -107,6 +109,11 @@ export class TagError extends Error {
  * ```
  */
 export class TagManager {
+    refStorage;
+    objectStorage;
+    gpgSigner;
+    // Simple in-memory lock to handle concurrent tag creation
+    pendingCreations = new Set();
     /**
      * Create a new TagManager.
      *
@@ -115,10 +122,9 @@ export class TagManager {
      * @param gpgSigner - Optional GPG signer for signed tags
      */
     constructor(refStorage, objectStorage, gpgSigner) {
-        void refStorage; // Suppress unused variable warning until implementation
-        void objectStorage;
-        void gpgSigner;
-        // TODO: Implement in GREEN phase
+        this.refStorage = refStorage;
+        this.objectStorage = objectStorage;
+        this.gpgSigner = gpgSigner;
     }
     /**
      * Create a new tag.
@@ -157,9 +163,98 @@ export class TagManager {
      * })
      * ```
      */
-    async createTag(_name, _target, _options) {
-        // TODO: Implement in GREEN phase
-        throw new Error('Not implemented');
+    async createTag(name, target, options) {
+        // Validate tag name
+        if (!isValidTagName(name)) {
+            throw new TagError(`Invalid tag name: ${name}`, 'INVALID_TAG_NAME', name);
+        }
+        const refName = `refs/tags/${name}`;
+        // Synchronous check-and-lock to handle concurrent creation attempts
+        if (this.pendingCreations.has(name)) {
+            throw new TagError(`Tag already exists: ${name}`, 'TAG_EXISTS', name);
+        }
+        // Check if tag already exists
+        const existingSha = await this.refStorage.getRef(refName);
+        if (existingSha !== null && !options?.force) {
+            throw new TagError(`Tag already exists: ${name}`, 'TAG_EXISTS', name);
+        }
+        // Mark as pending (synchronous operation for atomicity)
+        if (!options?.force) {
+            if (this.pendingCreations.has(name)) {
+                throw new TagError(`Tag already exists: ${name}`, 'TAG_EXISTS', name);
+            }
+            this.pendingCreations.add(name);
+        }
+        // Determine if this should be an annotated tag
+        const isAnnotated = options?.annotated === true || (options?.message !== undefined && options?.message !== '');
+        try {
+            if (isAnnotated) {
+                // Validate message for annotated tags
+                const rawMessage = options?.message;
+                if (!rawMessage || rawMessage.trim().length === 0) {
+                    throw new TagError('Annotated tag requires a message', 'MESSAGE_REQUIRED', name);
+                }
+                const formattedMessage = formatTagMessage(rawMessage);
+                // Validate tagger (can have timestamp set to 0 or undefined, we'll use current time)
+                let tagger = options?.tagger;
+                if (tagger && tagger.timestamp === undefined) {
+                    tagger = {
+                        ...tagger,
+                        timestamp: Math.floor(Date.now() / 1000)
+                    };
+                }
+                // Handle signing
+                let signature;
+                let finalMessage = formattedMessage;
+                if (options?.sign) {
+                    if (!this.gpgSigner) {
+                        throw new TagError('GPG signer not available', 'GPG_ERROR', name);
+                    }
+                    // Sign the tag content
+                    const encoder = new TextEncoder();
+                    signature = await this.gpgSigner.sign(encoder.encode(formattedMessage), options?.keyId);
+                    // Append signature to message (Git stores signature in the tag object)
+                    finalMessage = formattedMessage + '\n' + signature;
+                }
+                // Get the target object type
+                const targetType = await this.objectStorage.readObjectType(target);
+                // Create tag object
+                const tagObj = {
+                    object: target,
+                    objectType: targetType || 'commit',
+                    name,
+                    tagger,
+                    message: finalMessage
+                };
+                // Write tag object and get its SHA
+                const tagObjSha = await this.objectStorage.writeTagObject(tagObj);
+                // Write ref pointing to tag object
+                await this.refStorage.setRef(refName, tagObjSha);
+                return {
+                    name,
+                    type: 'annotated',
+                    sha: tagObjSha,
+                    targetSha: target,
+                    targetType: targetType || 'commit',
+                    tagger,
+                    message: formattedMessage,
+                    signature
+                };
+            }
+            else {
+                // Lightweight tag - just write ref pointing to target
+                await this.refStorage.setRef(refName, target);
+                return {
+                    name,
+                    type: 'lightweight',
+                    sha: target
+                };
+            }
+        }
+        finally {
+            // Clear the pending lock
+            this.pendingCreations.delete(name);
+        }
     }
     /**
      * Delete a tag.
@@ -181,9 +276,19 @@ export class TagManager {
      * await manager.deleteTag('maybe-exists', { force: true })
      * ```
      */
-    async deleteTag(_name, _options) {
-        // TODO: Implement in GREEN phase
-        throw new Error('Not implemented');
+    async deleteTag(name, options) {
+        const refName = `refs/tags/${name}`;
+        // Check if tag exists
+        const existingSha = await this.refStorage.getRef(refName);
+        if (existingSha === null) {
+            if (options?.force) {
+                return false;
+            }
+            throw new TagError(`Tag not found: ${name}`, 'TAG_NOT_FOUND', name);
+        }
+        // Delete the ref (but not the tag object)
+        await this.refStorage.deleteRef(refName);
+        return true;
     }
     /**
      * List all tags.
@@ -216,9 +321,79 @@ export class TagManager {
      * })
      * ```
      */
-    async listTags(_options) {
-        // TODO: Implement in GREEN phase
-        throw new Error('Not implemented');
+    async listTags(options) {
+        // List all refs under refs/tags/
+        const tagRefs = await this.refStorage.listRefs('refs/tags/');
+        // Determine if we need metadata (either explicitly requested or for date sorting)
+        const needMetadata = options?.includeMetadata || options?.sort === 'date';
+        // Build tag list
+        let tags = [];
+        for (const refEntry of tagRefs) {
+            const tagName = refEntry.name.replace('refs/tags/', '');
+            const sha = refEntry.sha;
+            // Check if it's an annotated tag by trying to read the tag object
+            const tagObj = await this.objectStorage.readTagObject(sha);
+            if (tagObj) {
+                // Annotated tag
+                const tag = {
+                    name: tagName,
+                    type: 'annotated',
+                    sha
+                };
+                if (needMetadata) {
+                    tag.targetSha = tagObj.object;
+                    tag.targetType = tagObj.objectType;
+                    tag.tagger = tagObj.tagger;
+                    tag.message = tagObj.message;
+                }
+                tags.push(tag);
+            }
+            else {
+                // Lightweight tag
+                tags.push({
+                    name: tagName,
+                    type: 'lightweight',
+                    sha
+                });
+            }
+        }
+        // Filter by pattern if provided
+        if (options?.pattern) {
+            tags = filterTagsByPattern(tags, options.pattern);
+        }
+        // Sort tags
+        const sortType = options?.sort || 'name';
+        const sortDirection = options?.sortDirection || 'asc';
+        if (sortType === 'version') {
+            tags = sortTagsByVersion(tags, sortDirection);
+        }
+        else if (sortType === 'date') {
+            // Filter out tags without timestamps when sorting by date
+            tags = tags.filter(t => t.tagger?.timestamp !== undefined);
+            // Sort by tagger timestamp
+            tags.sort((a, b) => {
+                const aTime = a.tagger.timestamp;
+                const bTime = b.tagger.timestamp;
+                const timeDiff = sortDirection === 'asc' ? aTime - bTime : bTime - aTime;
+                // Secondary sort by name when timestamps are equal
+                if (timeDiff === 0) {
+                    return a.name.localeCompare(b.name);
+                }
+                return timeDiff;
+            });
+        }
+        else {
+            // Sort by name (default)
+            tags.sort((a, b) => {
+                const cmp = a.name.localeCompare(b.name);
+                return sortDirection === 'asc' ? cmp : -cmp;
+            });
+        }
+        // Limit results
+        if (options?.limit !== undefined) {
+            tags = tags.slice(0, options.limit);
+        }
+        return tags;
     }
     /**
      * Get a tag by name.
@@ -244,9 +419,43 @@ export class TagManager {
      * }
      * ```
      */
-    async getTag(_name, _options) {
-        // TODO: Implement in GREEN phase
-        throw new Error('Not implemented');
+    async getTag(name, options) {
+        const refName = `refs/tags/${name}`;
+        const sha = await this.refStorage.getRef(refName);
+        if (sha === null) {
+            return null;
+        }
+        // Try to read as tag object (annotated tag)
+        const tagObj = await this.objectStorage.readTagObject(sha);
+        if (tagObj) {
+            // Annotated tag
+            const tag = {
+                name,
+                type: 'annotated',
+                sha
+            };
+            if (options?.resolve) {
+                tag.targetSha = tagObj.object;
+                tag.targetType = tagObj.objectType;
+                tag.tagger = tagObj.tagger;
+                tag.message = tagObj.message;
+                // Check for signature in message
+                const parsed = parseTagMessage(tagObj.message);
+                if (parsed.signature) {
+                    tag.signature = parsed.signature;
+                    tag.message = parsed.message;
+                }
+            }
+            return tag;
+        }
+        else {
+            // Lightweight tag
+            return {
+                name,
+                type: 'lightweight',
+                sha
+            };
+        }
     }
     /**
      * Check if a tag exists.
@@ -264,9 +473,10 @@ export class TagManager {
      * }
      * ```
      */
-    async tagExists(_name) {
-        // TODO: Implement in GREEN phase
-        throw new Error('Not implemented');
+    async tagExists(name) {
+        const refName = `refs/tags/${name}`;
+        const sha = await this.refStorage.getRef(refName);
+        return sha !== null;
     }
     /**
      * Get the target (commit SHA) that a tag points to.
@@ -285,9 +495,26 @@ export class TagManager {
      * const commitSha = await manager.getTagTarget('v1.0.0')
      * ```
      */
-    async getTagTarget(_name) {
-        // TODO: Implement in GREEN phase
-        throw new Error('Not implemented');
+    async getTagTarget(name) {
+        const refName = `refs/tags/${name}`;
+        let sha = await this.refStorage.getRef(refName);
+        if (sha === null) {
+            throw new TagError(`Tag not found: ${name}`, 'TAG_NOT_FOUND', name);
+        }
+        // Resolve through tag objects to get final commit
+        let depth = 0;
+        const maxDepth = 10;
+        while (depth < maxDepth) {
+            const tagObj = await this.objectStorage.readTagObject(sha);
+            if (!tagObj) {
+                // Not a tag object, this is the final target
+                return sha;
+            }
+            // Follow the tag to its target
+            sha = tagObj.object;
+            depth++;
+        }
+        return sha;
     }
     /**
      * Verify a tag's GPG signature.
@@ -311,9 +538,30 @@ export class TagManager {
      * }
      * ```
      */
-    async verifyTag(_name) {
-        // TODO: Implement in GREEN phase
-        throw new Error('Not implemented');
+    async verifyTag(name) {
+        const refName = `refs/tags/${name}`;
+        const sha = await this.refStorage.getRef(refName);
+        if (sha === null) {
+            throw new TagError(`Tag not found: ${name}`, 'TAG_NOT_FOUND', name);
+        }
+        // Get tag object
+        const tagObj = await this.objectStorage.readTagObject(sha);
+        if (!tagObj) {
+            // Lightweight tag - cannot be signed
+            return { valid: false };
+        }
+        // Parse message to check for signature
+        const parsed = parseTagMessage(tagObj.message);
+        if (!parsed.signature) {
+            // No signature
+            return { valid: false };
+        }
+        // Verify signature using GPG signer
+        if (!this.gpgSigner) {
+            return { valid: false, error: 'GPG signer not available' };
+        }
+        const encoder = new TextEncoder();
+        return this.gpgSigner.verify(encoder.encode(parsed.message), parsed.signature);
     }
     /**
      * Check if a tag is annotated.
@@ -332,9 +580,15 @@ export class TagManager {
      * }
      * ```
      */
-    async isAnnotatedTag(_name) {
-        // TODO: Implement in GREEN phase
-        throw new Error('Not implemented');
+    async isAnnotatedTag(name) {
+        const refName = `refs/tags/${name}`;
+        const sha = await this.refStorage.getRef(refName);
+        if (sha === null) {
+            throw new TagError(`Tag not found: ${name}`, 'TAG_NOT_FOUND', name);
+        }
+        // Try to read as tag object
+        const tagObj = await this.objectStorage.readTagObject(sha);
+        return tagObj !== null;
     }
 }
 // ============================================================================
@@ -369,9 +623,49 @@ export class TagManager {
  * isValidTagName('')              // false (empty)
  * ```
  */
-export function isValidTagName(_name) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export function isValidTagName(name) {
+    // Empty name is invalid
+    if (!name || name.length === 0 || name.trim().length === 0) {
+        return false;
+    }
+    // Cannot end with .lock
+    if (name.endsWith('.lock')) {
+        return false;
+    }
+    // Cannot contain ..
+    if (name.includes('..')) {
+        return false;
+    }
+    // Cannot contain @{
+    if (name.includes('@{')) {
+        return false;
+    }
+    // Cannot contain control characters (ASCII 0-31, 127), space, ~, ^, :, ?, *, [, \
+    const invalidChars = /[\x00-\x1f\x7f ~^:?*[\]\\]/;
+    if (invalidChars.test(name)) {
+        return false;
+    }
+    // Cannot end with /
+    if (name.endsWith('/')) {
+        return false;
+    }
+    // Split into components and check each
+    const components = name.split('/');
+    for (const component of components) {
+        // Cannot have empty components (// in path)
+        if (component.length === 0) {
+            return false;
+        }
+        // Cannot start with .
+        if (component.startsWith('.')) {
+            return false;
+        }
+        // Cannot end with .
+        if (component.endsWith('.')) {
+            return false;
+        }
+    }
+    return true;
 }
 /**
  * Type guard for annotated tags.
@@ -391,9 +685,10 @@ export function isValidTagName(_name) {
  * }
  * ```
  */
-export function isAnnotatedTag(_tag) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export function isAnnotatedTag(tag) {
+    return tag.type === 'annotated' &&
+        tag.tagger !== undefined &&
+        tag.message !== undefined;
 }
 /**
  * Format a tag message.
@@ -410,9 +705,18 @@ export function isAnnotatedTag(_tag) {
  * formatTagMessage('  Hello World  \r\n')  // 'Hello World\n'
  * ```
  */
-export function formatTagMessage(_message) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export function formatTagMessage(message) {
+    // Normalize line endings (CRLF -> LF)
+    let formatted = message.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    // Trim leading and trailing whitespace, but preserve internal structure
+    // The test expects 'Hello\r\nWorld\r\n' to become 'Hello\nWorld\n'
+    // So we trim leading whitespace, convert line endings, but preserve trailing newline if present
+    const hadTrailingNewline = formatted.endsWith('\n');
+    formatted = formatted.trim();
+    if (hadTrailingNewline && formatted.length > 0) {
+        formatted += '\n';
+    }
+    return formatted;
 }
 /**
  * Parse a tag message from raw content.
@@ -432,9 +736,17 @@ export function formatTagMessage(_message) {
  * }
  * ```
  */
-export function parseTagMessage(_content) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export function parseTagMessage(content) {
+    const sigMarker = '-----BEGIN PGP SIGNATURE-----';
+    const sigIndex = content.indexOf(sigMarker);
+    if (sigIndex === -1) {
+        // No signature
+        return { message: content.trim() };
+    }
+    // Split message and signature
+    const message = content.slice(0, sigIndex).trim();
+    const signature = content.slice(sigIndex);
+    return { message, signature };
 }
 // ============================================================================
 // Convenience Functions
@@ -459,9 +771,8 @@ export function parseTagMessage(_content) {
  * })
  * ```
  */
-export async function createTag(_manager, _name, _target, _options) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export async function createTag(manager, name, target, options) {
+    return manager.createTag(name, target, options);
 }
 /**
  * Create an annotated tag with message.
@@ -489,9 +800,13 @@ export async function createTag(_manager, _name, _target, _options) {
  * )
  * ```
  */
-export async function createAnnotatedTag(_manager, _name, _target, _message, _tagger, _options) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export async function createAnnotatedTag(manager, name, target, message, tagger, options) {
+    return manager.createTag(name, target, {
+        ...options,
+        annotated: true,
+        message,
+        tagger
+    });
 }
 /**
  * Delete a tag.
@@ -509,9 +824,8 @@ export async function createAnnotatedTag(_manager, _name, _target, _message, _ta
  * await deleteTag(manager, 'v0.9.0-beta')
  * ```
  */
-export async function deleteTag(_manager, _name, _options) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export async function deleteTag(manager, name, options) {
+    return manager.deleteTag(name, options);
 }
 /**
  * List all tags.
@@ -528,9 +842,8 @@ export async function deleteTag(_manager, _name, _options) {
  * const tags = await listTags(manager, { pattern: 'v1.*' })
  * ```
  */
-export async function listTags(_manager, _options) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export async function listTags(manager, options) {
+    return manager.listTags(options);
 }
 /**
  * Get a tag by name.
@@ -548,9 +861,8 @@ export async function listTags(_manager, _options) {
  * const tag = await getTag(manager, 'v1.0.0', { resolve: true })
  * ```
  */
-export async function getTag(_manager, _name, _options) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export async function getTag(manager, name, options) {
+    return manager.getTag(name, options);
 }
 /**
  * Check if a tag is annotated.
@@ -569,9 +881,8 @@ export async function getTag(_manager, _name, _options) {
  * }
  * ```
  */
-export async function checkIsAnnotatedTag(_manager, _name) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export async function checkIsAnnotatedTag(manager, name) {
+    return manager.isAnnotatedTag(name);
 }
 /**
  * Verify a tag's signature.
@@ -588,9 +899,8 @@ export async function checkIsAnnotatedTag(_manager, _name) {
  * const result = await verifyTagSignature(manager, 'v1.0.0')
  * ```
  */
-export async function verifyTagSignature(_manager, _name) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export async function verifyTagSignature(manager, name) {
+    return manager.verifyTag(name);
 }
 /**
  * Get the target commit SHA for a tag.
@@ -607,9 +917,8 @@ export async function verifyTagSignature(_manager, _name) {
  * const sha = await getTagTarget(manager, 'v1.0.0')
  * ```
  */
-export async function getTagTarget(_manager, _name) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export async function getTagTarget(manager, name) {
+    return manager.getTagTarget(name);
 }
 /**
  * Sort tags by semantic version.
@@ -628,9 +937,33 @@ export async function getTagTarget(_manager, _name) {
  * // ['v2.0.0', 'v1.10.0', 'v1.9.0', 'v1.0.0', ...]
  * ```
  */
-export function sortTagsByVersion(_tags, _direction = 'asc') {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export function sortTagsByVersion(tags, direction = 'asc') {
+    // Parse version from tag name (handles v1.2.3, 1.2.3, v1.2.3-beta, etc.)
+    const parseVersion = (name) => {
+        // Remove 'v' prefix if present
+        const normalized = name.startsWith('v') ? name.slice(1) : name;
+        // Extract numeric version parts (split on non-digit, non-dot)
+        const parts = normalized.split(/[^0-9.]/)[0].split('.');
+        return parts.map(p => parseInt(p, 10) || 0);
+    };
+    const compareVersions = (a, b) => {
+        const maxLen = Math.max(a.length, b.length);
+        for (let i = 0; i < maxLen; i++) {
+            const aVal = a[i] || 0;
+            const bVal = b[i] || 0;
+            if (aVal !== bVal) {
+                return aVal - bVal;
+            }
+        }
+        return 0;
+    };
+    const sorted = [...tags].sort((a, b) => {
+        const aVer = parseVersion(a.name);
+        const bVer = parseVersion(b.name);
+        const cmp = compareVersions(aVer, bVer);
+        return direction === 'asc' ? cmp : -cmp;
+    });
+    return sorted;
 }
 /**
  * Filter tags by glob pattern.
@@ -648,8 +981,16 @@ export function sortTagsByVersion(_tags, _direction = 'asc') {
  * const v1Tags = filterTagsByPattern(tags, 'v1.*')
  * ```
  */
-export function filterTagsByPattern(_tags, _pattern) {
-    // TODO: Implement in GREEN phase
-    throw new Error('Not implemented');
+export function filterTagsByPattern(tags, pattern) {
+    // Convert glob pattern to regex
+    // * matches any number of characters
+    // ? matches a single character
+    // Escape special regex characters except * and ?
+    const regexPattern = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape special regex chars
+        .replace(/\*/g, '.*') // * -> .*
+        .replace(/\?/g, '.'); // ? -> .
+    const regex = new RegExp(`^${regexPattern}$`);
+    return tags.filter(tag => regex.test(tag.name));
 }
 //# sourceMappingURL=tag.js.map