dsh-git-branch-manage 1.0.5 → 1.0.7

package/lib/git.d.ts

@@ -182,6 +182,28 @@ export declare function switchBranch(exec: Exec, checkoutDir: string, branch: st
  * start point with `checkout` false).
  */
 export declare function createBranch(exec: Exec, cwd: string, name: string, from?: string, checkout?: boolean): Promise<string>;
+/** Outcome of {@link createTag}: the tag created and the commit it points at. */
+export interface TagOutcome {
+    tag: string;
+    hash: string;
+}
+/**
+ * Create a tag at an existing commit (`git tag`). Tags are repository-wide
+ * refs, so the command runs at the repository root.
+ *
+ * A message makes it an ANNOTATED tag (`-a -m`) — the only shape that carries
+ * an author and date, and what `git describe` prefers; without one the tag is
+ * lightweight and is just an alias for the commit. Both are created locally
+ * only: pushing a tag is a deliberate, separate publish step that this panel
+ * does not perform on a menu click.
+ * @param exec - executor seam.
+ * @param repoRoot - main worktree directory.
+ * @param name - tag name (git validates; failures raise GitError).
+ * @param target - commit to tag; absent tags the repository's current HEAD.
+ * @param message - optional annotation message; non-empty = annotated tag.
+ * @returns the tag name and the commit hash it points at.
+ */
+export declare function createTag(exec: Exec, repoRoot: string, name: string, target?: string, message?: string): Promise<TagOutcome>;
 /**
  * Rename a LOCAL branch (`git branch -m`): branch refs are repository-wide,
  * so the command runs at the repository root and every worktree HEAD pointing
@@ -279,6 +301,57 @@ export interface PushOutcome {
  * push-specific diagnostic is preserved; in that case `pushed` is false.
  */
 export declare function pushBranch(exec: Exec, cwd: string): Promise<PushOutcome>;
+/** Every LOCAL tag name of the repository, in git's own sort order. */
+export declare function listTagNames(exec: Exec, cwd: string): Promise<string[]>;
+/** Where a one-off push should go, or why no remote could be picked. */
+export type PushRemoteChoice = {
+    readonly ok: true;
+    readonly remote: string;
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+/**
+ * Pick the remote ONE tag push goes to, in fallback order: the checked-out
+ * branch's upstream remote, `remote.pushDefault`, then the only remote there
+ * is. Ambiguity is reported instead of guessed — a tag pushed to the wrong
+ * remote is a published mistake, not an inconvenience.
+ * @param exec - executor seam.
+ * @param cwd - directory whose checked-out branch supplies the upstream.
+ * @returns the remote name, or the caller-side reason none could be chosen.
+ */
+export declare function resolvePushRemote(exec: Exec, cwd: string): Promise<PushRemoteChoice>;
+/** Outcome of {@link pushTag}: the tag, where it went, and whether it moved. */
+export interface TagPushOutcome {
+    tag: string;
+    remote: string;
+    pushed: boolean;
+}
+/**
+ * Push ONE existing local tag to `remote` (`git push <remote>
+ * refs/tags/<name>:refs/tags/<name>`) — the publish step a tag needs and a
+ * branch push never performs: `git push` sends the current branch alone, so a
+ * tag made on an already-pushed commit is invisible to the remote.
+ *
+ * The tag must already exist locally (the route verifies it against
+ * {@link listTagNames}); a remote that already carries the SAME tag object is
+ * reported as `pushed: false` without running the push at all. The refspec
+ * always names both sides explicitly, so no configured push refspec (a mirror,
+ * a `push.default=upstream` branch) can widen what a menu click publishes, and
+ * tags are never deleted or overwritten: `--force` is deliberately absent, and
+ * a remote tag pointing somewhere else makes git refuse (mapped to 400).
+ *
+ * The cn-accelerate rewrite is never injected here (no {@link accelArgs}
+ * parameter exists, like {@link pushBranch}): a mirror has no `receive-pack` —
+ * and the pre-push probe must see the very remote the push targets, or the
+ * `pushed` flag would compare two different servers.
+ * @param exec - executor seam.
+ * @param cwd - any directory inside the repository (tag refs are shared).
+ * @param name - an existing local tag name.
+ * @param remote - the remote to publish to (see {@link resolvePushRemote}).
+ * @returns the tag, the remote, and whether the push had to run.
+ */
+export declare function pushTag(exec: Exec, cwd: string, name: string, remote: string): Promise<TagPushOutcome>;
 /** Guard for route inputs: a non-empty absolute directory path. */
 export declare function isAbsoluteDir(value: string): boolean;
 /** Pre-delete facts of one worktree directory, for the remove-confirm dialog. */
@@ -447,18 +520,34 @@ export interface CommitEntryRaw {
     body: string;
     refs: string[];
 }
+/** The extra log filters the history card's toolbar drives. */
+export interface LogFilter {
+    /** Every ref (local + remote branches, tags) instead of the checkout's
+     * HEAD — the history card's default view. Ignored when `ref` is given. */
+    all?: boolean;
+    /** Committer-author substring/regex, forwarded as `--author=<value>`. */
+    author?: string;
+    /** Lower/upper bound on the commit date, epoch milliseconds. */
+    since?: number;
+    until?: number;
+}
 /**
  * Paginated history of the queried checkout. `ref` is verified with
  * `rev-parse --verify` first, so an arbitrary string can never reach the log
  * arguments as anything but a resolvable rev. An unborn checkout (no commits
  * yet) answers an empty page instead of an error.
+ *
+ * `--topo-order` is unconditional: the history card draws lane lines from
+ * `parents`, and a pure date order would interleave a branch's commits
+ * before their merge base, leaving edges pointing at rows not yet painted.
  * @param exec - executor seam.
  * @param cwd - the checkout directory.
  * @param limit - page size (1..200, validated upstream).
  * @param skip - offset (>= 0, validated upstream).
  * @param ref - optional starting rev; absent = the checkout's HEAD.
+ * @param filter - optional all-refs/author/date window.
  */
-export declare function logHistory(exec: Exec, cwd: string, limit: number, skip: number, ref?: string): Promise<CommitEntryRaw[]>;
+export declare function logHistory(exec: Exec, cwd: string, limit: number, skip: number, ref?: string, filter?: LogFilter): Promise<CommitEntryRaw[]>;
 /** One file row of {@link commitFiles}. */
 export interface CommitFileRow {
     path: string;

package/lib/git.js

@@ -433,6 +433,35 @@ export async function createBranch(exec, cwd, name, from, checkout = false) {
     await git(exec, cwd, ['branch', name, from]);
     return name;
 }
+/**
+ * Create a tag at an existing commit (`git tag`). Tags are repository-wide
+ * refs, so the command runs at the repository root.
+ *
+ * A message makes it an ANNOTATED tag (`-a -m`) — the only shape that carries
+ * an author and date, and what `git describe` prefers; without one the tag is
+ * lightweight and is just an alias for the commit. Both are created locally
+ * only: pushing a tag is a deliberate, separate publish step that this panel
+ * does not perform on a menu click.
+ * @param exec - executor seam.
+ * @param repoRoot - main worktree directory.
+ * @param name - tag name (git validates; failures raise GitError).
+ * @param target - commit to tag; absent tags the repository's current HEAD.
+ * @param message - optional annotation message; non-empty = annotated tag.
+ * @returns the tag name and the commit hash it points at.
+ */
+export async function createTag(exec, repoRoot, name, target, message) {
+    const text = message?.trim() ?? '';
+    const args = ['tag'];
+    if (text !== '')
+        args.push('-a', name, '-m', text);
+    else
+        args.push(name);
+    if (target !== undefined && target !== '')
+        args.push(target);
+    await git(exec, repoRoot, args);
+    const hash = (await git(exec, repoRoot, ['rev-list', '-n', '1', name])).trim();
+    return { tag: name, hash };
+}
 /**
  * Rename a LOCAL branch (`git branch -m`): branch refs are repository-wide,
  * so the command runs at the repository root and every worktree HEAD pointing
@@ -545,6 +574,73 @@ export async function pushBranch(exec, cwd) {
     const branch = (await gitMaybe(exec, cwd, ['branch', '--show-current']))?.trim() ?? '';
     return { branch, pushed: before !== undefined && after !== undefined && before.trim() !== after.trim() };
 }
+/** Every LOCAL tag name of the repository, in git's own sort order. */
+export async function listTagNames(exec, cwd) {
+    const text = await git(exec, cwd, ['for-each-ref', 'refs/tags', '--format=%(refname:short)']);
+    return text.split('\n').map(line => line.trim()).filter(line => line !== '');
+}
+/**
+ * Pick the remote ONE tag push goes to, in fallback order: the checked-out
+ * branch's upstream remote, `remote.pushDefault`, then the only remote there
+ * is. Ambiguity is reported instead of guessed — a tag pushed to the wrong
+ * remote is a published mistake, not an inconvenience.
+ * @param exec - executor seam.
+ * @param cwd - directory whose checked-out branch supplies the upstream.
+ * @returns the remote name, or the caller-side reason none could be chosen.
+ */
+export async function resolvePushRemote(exec, cwd) {
+    const upstream = (await gitMaybe(exec, cwd, ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}']))?.trim() ?? '';
+    const slash = upstream.indexOf('/');
+    if (slash > 0)
+        return { ok: true, remote: upstream.slice(0, slash) };
+    const pushDefault = (await gitMaybe(exec, cwd, ['config', '--get', 'remote.pushDefault']))?.trim() ?? '';
+    if (pushDefault !== '')
+        return { ok: true, remote: pushDefault };
+    const remotes = ((await gitMaybe(exec, cwd, ['remote'])) ?? '')
+        .split('\n').map(line => line.trim()).filter(line => line !== '');
+    const only = remotes.length === 1 ? remotes[0] : undefined;
+    if (only !== undefined)
+        return { ok: true, remote: only };
+    return { ok: false, message: remotes.length === 0
+            ? 'no remote to push the tag to: the current branch has no upstream and the repository has none either'
+            : `multiple remotes (${remotes.join(', ')}) and the current branch has no upstream: set one, or git config remote.pushDefault <name>` };
+}
+/**
+ * Push ONE existing local tag to `remote` (`git push <remote>
+ * refs/tags/<name>:refs/tags/<name>`) — the publish step a tag needs and a
+ * branch push never performs: `git push` sends the current branch alone, so a
+ * tag made on an already-pushed commit is invisible to the remote.
+ *
+ * The tag must already exist locally (the route verifies it against
+ * {@link listTagNames}); a remote that already carries the SAME tag object is
+ * reported as `pushed: false` without running the push at all. The refspec
+ * always names both sides explicitly, so no configured push refspec (a mirror,
+ * a `push.default=upstream` branch) can widen what a menu click publishes, and
+ * tags are never deleted or overwritten: `--force` is deliberately absent, and
+ * a remote tag pointing somewhere else makes git refuse (mapped to 400).
+ *
+ * The cn-accelerate rewrite is never injected here (no {@link accelArgs}
+ * parameter exists, like {@link pushBranch}): a mirror has no `receive-pack` —
+ * and the pre-push probe must see the very remote the push targets, or the
+ * `pushed` flag would compare two different servers.
+ * @param exec - executor seam.
+ * @param cwd - any directory inside the repository (tag refs are shared).
+ * @param name - an existing local tag name.
+ * @param remote - the remote to publish to (see {@link resolvePushRemote}).
+ * @returns the tag, the remote, and whether the push had to run.
+ */
+export async function pushTag(exec, cwd, name, remote) {
+    const ref = `refs/tags/${name}`;
+    const local = (await git(exec, cwd, ['rev-parse', '--verify', ref])).trim();
+    const listed = await gitMaybe(exec, cwd, ['ls-remote', '--refs', remote, ref], NETWORK_TIMEOUT_MS);
+    const present = (listed ?? '').split('\n')
+        .map(line => line.trim().split(/\s+/)[0] ?? '')
+        .includes(local);
+    if (present)
+        return { tag: name, remote, pushed: false };
+    await git(exec, cwd, ['push', remote, `${ref}:${ref}`], NETWORK_TIMEOUT_MS);
+    return { tag: name, remote, pushed: true };
+}
 /** Guard for route inputs: a non-empty absolute directory path. */
 export function isAbsoluteDir(value) {
     return value.trim() !== '' && isAbsolute(value);
@@ -879,13 +975,18 @@ export function parseLogOutput(out) {
  * `rev-parse --verify` first, so an arbitrary string can never reach the log
  * arguments as anything but a resolvable rev. An unborn checkout (no commits
  * yet) answers an empty page instead of an error.
+ *
+ * `--topo-order` is unconditional: the history card draws lane lines from
+ * `parents`, and a pure date order would interleave a branch's commits
+ * before their merge base, leaving edges pointing at rows not yet painted.
  * @param exec - executor seam.
  * @param cwd - the checkout directory.
  * @param limit - page size (1..200, validated upstream).
  * @param skip - offset (>= 0, validated upstream).
  * @param ref - optional starting rev; absent = the checkout's HEAD.
+ * @param filter - optional all-refs/author/date window.
  */
-export async function logHistory(exec, cwd, limit, skip, ref) {
+export async function logHistory(exec, cwd, limit, skip, ref, filter) {
     let start;
     if (ref !== undefined && ref !== '' && ref !== 'HEAD') {
         const verified = await gitMaybe(exec, cwd, ['rev-parse', '--verify', '--quiet', `${ref}^{commit}`]);
@@ -894,10 +995,21 @@ export async function logHistory(exec, cwd, limit, skip, ref) {
         }
         start = verified.trim();
     }
+    // A ref narrows the walk to that ref's ancestry; `--all` is only the
+    // no-ref default. Combining them would list every branch under a
+    // "this branch" filter.
+    const all = filter?.all === true && start === undefined;
+    const author = filter?.author?.trim() ?? '';
+    const since = filter?.since;
+    const until = filter?.until;
     try {
         const out = await git(exec, cwd, [
-            'log', `--max-count=${String(limit)}`, `--skip=${String(skip)}`,
+            'log', `--max-count=${String(limit)}`, `--skip=${String(skip)}`, '--topo-order',
             '--date=iso-strict', `--pretty=format:${LOG_FORMAT}`,
+            ...(all ? ['--all'] : []),
+            ...(author === '' ? [] : [`--author=${author}`]),
+            ...(since === undefined ? [] : [`--since=${new Date(since).toISOString()}`]),
+            ...(until === undefined ? [] : [`--until=${new Date(until).toISOString()}`]),
             ...(start === undefined ? [] : [start]),
         ]);
         return parseLogOutput(out);

package/lib/index.js

@@ -9,9 +9,9 @@ import { homedir } from 'node:os';
 import z from '@deepseek-ai/schemastery';
 import { childProcessExec } from './git.js';
 import { ACCEL_DEFAULT_URL, accelerateUrlError } from './normalize.js';
-import { handleAiCommitMessage, handleChanges, handleCommit, handleCommitFiles, handleCreateBranch, handleCreateWorktree, handleDeleteBranch, handleEnsureDirectory, handleFetch, handleGroupWorktrees, handleInspectWorktree, handleLog, handlePathExists, handlePurgeDirectory, handleRemoveWorktree, handleRenameBranch, handleStage, handleStatus, handleSwitch, handleUpdate, handlePush, handleWorktreesAll, } from './routes.js';
+import { handleAiCommitMessage, handleChanges, handleCommit, handleCommitFiles, handleCreateBranch, handleCreateTag, handleCreateWorktree, handleDeleteBranch, handleEnsureDirectory, handleFetch, handleGroupWorktrees, handleInspectWorktree, handleLog, handlePathExists, handlePurgeDirectory, handlePushTag, handleRemoveWorktree, handleRenameBranch, handleStage, handleStatus, handleSwitch, handleUpdate, handlePush, handleWorktreesAll, } from './routes.js';
 import { validateRootDir } from './settings.js';
-import { ROUTE_AI_COMMIT_MESSAGE, ROUTE_BRANCH, ROUTE_BRANCH_DELETE, ROUTE_BRANCH_RENAME, ROUTE_CHANGES, ROUTE_COMMIT, ROUTE_COMMIT_FILES, ROUTE_ENSURE_DIRECTORY, ROUTE_EXISTS, ROUTE_FETCH, ROUTE_GROUP, ROUTE_INSPECT, ROUTE_LOG, ROUTE_PUSH, ROUTE_PURGE, ROUTE_REMOVE, ROUTE_STAGE, ROUTE_STATUS, ROUTE_SWITCH, ROUTE_UPDATE, ROUTE_WORKTREE, ROUTE_WORKTREES_ALL } from './wire.js';
+import { ROUTE_AI_COMMIT_MESSAGE, ROUTE_BRANCH, ROUTE_BRANCH_DELETE, ROUTE_BRANCH_RENAME, ROUTE_CHANGES, ROUTE_COMMIT, ROUTE_COMMIT_FILES, ROUTE_ENSURE_DIRECTORY, ROUTE_EXISTS, ROUTE_FETCH, ROUTE_GROUP, ROUTE_INSPECT, ROUTE_LOG, ROUTE_PUSH, ROUTE_PURGE, ROUTE_REMOVE, ROUTE_STAGE, ROUTE_STATUS, ROUTE_SWITCH, ROUTE_TAG, ROUTE_TAG_PUSH, ROUTE_UPDATE, ROUTE_WORKTREE, ROUTE_WORKTREES_ALL } from './wire.js';
 export const name = 'dsh-git-branch';
 export const inject = [];
 /** Largest accepted request body (bytes) — these payloads are a few strings. */
@@ -227,6 +227,8 @@ export function apply(ctx, config = {}) {
         postRoute(ROUTE_COMMIT, 'commit', handleCommit);
         postRoute(ROUTE_LOG, 'log', handleLog);
         postRoute(ROUTE_COMMIT_FILES, 'commit-files', handleCommitFiles);
+        postRoute(ROUTE_TAG, 'tag', handleCreateTag);
+        postRoute(ROUTE_TAG_PUSH, 'tag-push', handlePushTag);
         // The AI commit-message route exists only where the host tree provides
         // the dsh-llm service: the injection resolves once the service is up and
         // never fires without it, so an llm-less deployment answers 404 and the

package/lib/routes.d.ts

@@ -4,7 +4,7 @@
  */
 import { type CopyFilesSeams } from './copy-files.js';
 import { type DirExists, type ExcludeSeams, type Exec } from './git.js';
-import type { AiCommitMessageResult, ChangesResult, CommitFilesResult, CommitResult, CreateBranchResult, CreateWorktreeResult, EnsureDirectoryResult, FetchResult, GroupWorkspacesResult, InspectWorktreeResult, LogResult, PathExistsResult, PurgeDirectoryResult, RemoveWorktreeResult, RepoStatus, RouteError, StageResult, SwitchResult, UpdateResult, WorktreesAllResult } from './wire.js';
+import type { AiCommitMessageResult, ChangesResult, CommitFilesResult, CommitResult, CreateBranchResult, CreateTagResult, CreateWorktreeResult, EnsureDirectoryResult, FetchResult, GroupWorkspacesResult, InspectWorktreeResult, LogResult, PathExistsResult, PurgeDirectoryResult, PushTagResult, RemoveWorktreeResult, RepoStatus, RouteError, StageResult, SwitchResult, UpdateResult, WorktreesAllResult } from './wire.js';
 /** Everything the handlers need from the host half. */
 export interface RouteDeps {
     exec: Exec;
@@ -50,7 +50,7 @@ export declare function fsMkdirRecursive(path: string): Promise<void>;
 /** One route outcome: HTTP status plus the JSON body. */
 export interface RouteOutcome {
     status: number;
-    body: RepoStatus | CreateWorktreeResult | SwitchResult | CreateBranchResult | FetchResult | UpdateResult | GroupWorkspacesResult | InspectWorktreeResult | RemoveWorktreeResult | PathExistsResult | EnsureDirectoryResult | WorktreesAllResult | PurgeDirectoryResult | ChangesResult | StageResult | CommitResult | LogResult | CommitFilesResult | AiCommitMessageResult | RouteError;
+    body: RepoStatus | CreateWorktreeResult | SwitchResult | CreateBranchResult | FetchResult | UpdateResult | GroupWorkspacesResult | InspectWorktreeResult | RemoveWorktreeResult | PathExistsResult | EnsureDirectoryResult | WorktreesAllResult | PurgeDirectoryResult | ChangesResult | StageResult | CommitResult | LogResult | CommitFilesResult | CreateTagResult | PushTagResult | AiCommitMessageResult | RouteError;
 }
 /**
  * POST /group — git belonging facts for a batch of workspace directories.
@@ -274,10 +274,40 @@ export declare const LOG_LIMIT_MAX = 200;
  * POST /log — one page of the queried checkout's history. The optional `ref`
  * is verified server-side (`rev-parse --verify`), an unborn checkout answers
  * an empty page, and everything else surfaces git's own stderr.
+ *
+ * `all` walks every ref instead of HEAD (the history card's default view: one
+ * graph holding all branches, tags, and their merge edges). `author` and the
+ * `since`/`until` window are pushed down to git rather than filtered in the
+ * browser — the card paginates, so a client-side filter would only narrow the
+ * page it already has and silently hide matches on later pages.
  * @param deps - host dependencies.
- * @param body - parsed request body: `{ repoPath, limit?, skip?, ref? }`.
+ * @param body - parsed request body: `{ repoPath, limit?, skip?, ref?, all?, author?, since?, until? }`.
  */
 export declare function handleLog(deps: RouteDeps, body: unknown): Promise<RouteOutcome>;
+/**
+ * POST /tag — create a tag at an existing commit of the queried repository.
+ * The target is restricted to a commit hash (the only shape the history card
+ * sends), so an arbitrary string can never reach `git tag` as a flag; git
+ * validates the tag name itself and a duplicate surfaces as 400.
+ * @param deps - host dependencies.
+ * @param body - parsed request body: `{ repoPath, name, target?, message? }`.
+ */
+export declare function handleCreateTag(deps: RouteDeps, body: unknown): Promise<RouteOutcome>;
+/**
+ * POST /tag-push — publish ONE existing local tag to a remote. Separate from
+ * `POST /push` on purpose: a branch push sends the branch alone, so a tag on
+ * an already-pushed commit needs its own verb.
+ *
+ * The name must match a LOCAL tag this repository actually has (checked
+ * against `for-each-ref refs/tags`), so no free string ever reaches git as a
+ * flag or a refspec; the remote is resolved server-side and an ambiguous
+ * choice is 400. A remote that already carries the same tag object answers
+ * `pushed: false` (nothing was sent); a diverged remote tag is git's own
+ * refusal, mapped to 400 by {@link gitFailure} — never forced.
+ * @param deps - host dependencies.
+ * @param body - parsed request body: `{ repoPath, name }`.
+ */
+export declare function handlePushTag(deps: RouteDeps, body: unknown): Promise<RouteOutcome>;
 /**
  * POST /commit-files — the files one commit of the queried checkout changed.
  * The hash is verified server-side; unknown revisions answer 400.

package/lib/routes.js

@@ -5,7 +5,7 @@
 import { basename, dirname, join, resolve } from 'node:path';
 import { mkdir, readdir, rm, stat } from 'node:fs/promises';
 import { runPostCreateCopy } from './copy-files.js';
-import { appendWorktreeExclude, fsExcludeSeams, GitError, addWorktree, addWorktreeCutout, collectAiDiff, commitFiles, commitIndex, createBranch, cutoutBranchName, deleteBranch, fetchAll, fsDirExists, inspectWorktree, isAbsoluteDir, isStageablePath, logHistory, probeRepo, probeWorkspaceGit, removeWorktree, renameBranch, resolveBranch, pushBranch, stagePaths, switchBranch, updateBranch, workingChanges } from './git.js';
+import { appendWorktreeExclude, fsExcludeSeams, GitError, addWorktree, addWorktreeCutout, collectAiDiff, commitFiles, commitIndex, createBranch, createTag, cutoutBranchName, deleteBranch, fetchAll, fsDirExists, inspectWorktree, isAbsoluteDir, isStageablePath, listTagNames, logHistory, probeRepo, probeWorkspaceGit, pushTag, removeWorktree, renameBranch, resolveBranch, resolvePushRemote, pushBranch, stagePaths, switchBranch, updateBranch, workingChanges } from './git.js';
 import { ACCEL_DEFAULT_URL, accelerateUrlError, isAbsoluteConfigPath, normalizeAccelerateUrl, sanitizeBranchDir } from './normalize.js';
 import { resolveRootDir } from './settings.js';
 import { COMMIT_MESSAGE_LIMIT } from './wire.js';
@@ -1006,15 +1006,26 @@ export async function handleCommit(deps, body) {
 /** Default and maximum page size of POST /log. */
 export const LOG_LIMIT_DEFAULT = 50;
 export const LOG_LIMIT_MAX = 200;
+/** Bound for the author filter and the tag annotation (characters). */
+const LOG_AUTHOR_LIMIT = 200;
+const TAG_MESSAGE_LIMIT = 5000;
+/** Bound for one tag NAME (characters), shared by create and push. */
+const TAG_NAME_LIMIT = 300;
 /**
  * POST /log — one page of the queried checkout's history. The optional `ref`
  * is verified server-side (`rev-parse --verify`), an unborn checkout answers
  * an empty page, and everything else surfaces git's own stderr.
+ *
+ * `all` walks every ref instead of HEAD (the history card's default view: one
+ * graph holding all branches, tags, and their merge edges). `author` and the
+ * `since`/`until` window are pushed down to git rather than filtered in the
+ * browser — the card paginates, so a client-side filter would only narrow the
+ * page it already has and silently hide matches on later pages.
  * @param deps - host dependencies.
- * @param body - parsed request body: `{ repoPath, limit?, skip?, ref? }`.
+ * @param body - parsed request body: `{ repoPath, limit?, skip?, ref?, all?, author?, since?, until? }`.
  */
 export async function handleLog(deps, body) {
-    const parsed = readBody(body, ['repoPath'], [], ['ref'], ['limit', 'skip']);
+    const parsed = readBody(body, ['repoPath'], ['all'], ['ref', 'author'], ['limit', 'skip', 'since', 'until']);
     if (isOutcome(parsed))
         return parsed;
     const repoPath = readRepoPath(parsed);
@@ -1031,14 +1042,130 @@ export async function handleLog(deps, body) {
     if (ref !== undefined && (ref.trim() === '' || ref.length > 300 || ref.startsWith('-'))) {
         return fail(400, '"ref" must be a non-empty revision name');
     }
+    const author = parsed.author;
+    if (author !== undefined && (author.trim() === '' || author.length > LOG_AUTHOR_LIMIT)) {
+        return fail(400, `"author" must be a non-empty string of at most ${String(LOG_AUTHOR_LIMIT)} characters`);
+    }
+    const since = parsed.since;
+    const until = parsed.until;
+    for (const [key, value] of [['since', since], ['until', until]]) {
+        if (value !== undefined && (!Number.isFinite(value) || value <= 0)) {
+            return fail(400, `"${key}" must be a positive epoch-millisecond timestamp`);
+        }
+    }
+    if (since !== undefined && until !== undefined && until < since) {
+        return fail(400, '"until" must not be earlier than "since"');
+    }
     try {
-        const commits = await logHistory(deps.exec, repoPath, limit, skip, ref);
+        const commits = await logHistory(deps.exec, repoPath, limit, skip, ref, {
+            all: parsed.all === true,
+            ...(author === undefined ? {} : { author }),
+            ...(since === undefined ? {} : { since }),
+            ...(until === undefined ? {} : { until }),
+        });
         return { status: 200, body: { commits } };
     }
     catch (error) {
         return checkoutFailure(error);
     }
 }
+/**
+ * POST /tag — create a tag at an existing commit of the queried repository.
+ * The target is restricted to a commit hash (the only shape the history card
+ * sends), so an arbitrary string can never reach `git tag` as a flag; git
+ * validates the tag name itself and a duplicate surfaces as 400.
+ * @param deps - host dependencies.
+ * @param body - parsed request body: `{ repoPath, name, target?, message? }`.
+ */
+export async function handleCreateTag(deps, body) {
+    const parsed = readBody(body, ['repoPath', 'name'], [], ['target', 'message']);
+    if (isOutcome(parsed))
+        return parsed;
+    const { repoPath, name, target, message } = parsed;
+    if (!isAbsoluteDir(repoPath))
+        return fail(400, '"repoPath" must be an absolute directory');
+    if (name.trim() === '')
+        return fail(400, '"name" must be non-empty');
+    // A leading dash would ride `git tag` as a flag — reject before the exec.
+    if (name.startsWith('-'))
+        return fail(400, '"name" must not start with "-"');
+    if (name.length > TAG_NAME_LIMIT)
+        return fail(400, `"name" must be at most ${String(TAG_NAME_LIMIT)} characters`);
+    // The target lands on `git tag <name> <target>` verbatim: restrict it to the
+    // object id shape the history card sends rather than trusting a free string.
+    if (target !== undefined && !/^[0-9a-fA-F]{4,64}$/.test(target)) {
+        return fail(400, '"target" must be a git object id');
+    }
+    if (message !== undefined && message.length > TAG_MESSAGE_LIMIT) {
+        return fail(400, `"message" must be at most ${String(TAG_MESSAGE_LIMIT)} characters`);
+    }
+    try {
+        const facts = await probeRepo(deps.exec, repoPath, deps.dirExists);
+        if (facts === undefined)
+            return fail(400, `"${repoPath}" is not inside a git repository`);
+        // Tag refs are repository-wide metadata and touch no checkout, so the
+        // command runs at the repository root — the same scope as a branch rename.
+        const result = await createTag(deps.exec, facts.repoRoot, name, target, message);
+        const body = result;
+        return { status: 200, body };
+    }
+    catch (error) {
+        if (error instanceof GitError)
+            return gitFailure(error);
+        return fail(500, error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * POST /tag-push — publish ONE existing local tag to a remote. Separate from
+ * `POST /push` on purpose: a branch push sends the branch alone, so a tag on
+ * an already-pushed commit needs its own verb.
+ *
+ * The name must match a LOCAL tag this repository actually has (checked
+ * against `for-each-ref refs/tags`), so no free string ever reaches git as a
+ * flag or a refspec; the remote is resolved server-side and an ambiguous
+ * choice is 400. A remote that already carries the same tag object answers
+ * `pushed: false` (nothing was sent); a diverged remote tag is git's own
+ * refusal, mapped to 400 by {@link gitFailure} — never forced.
+ * @param deps - host dependencies.
+ * @param body - parsed request body: `{ repoPath, name }`.
+ */
+export async function handlePushTag(deps, body) {
+    const parsed = readBody(body, ['repoPath', 'name']);
+    if (isOutcome(parsed))
+        return parsed;
+    const { repoPath, name } = parsed;
+    if (!isAbsoluteDir(repoPath))
+        return fail(400, '"repoPath" must be an absolute directory');
+    if (name.trim() === '')
+        return fail(400, '"name" must be non-empty');
+    // A leading dash would ride `git push` as a flag — reject before the exec.
+    if (name.startsWith('-'))
+        return fail(400, '"name" must not start with "-"');
+    if (name.length > TAG_NAME_LIMIT)
+        return fail(400, `"name" must be at most ${String(TAG_NAME_LIMIT)} characters`);
+    try {
+        const facts = await probeRepo(deps.exec, repoPath, deps.dirExists);
+        if (facts === undefined)
+            return fail(400, `"${repoPath}" is not inside a git repository`);
+        // The push runs at the queried directory's own toplevel, so the remote is
+        // the one ITS checked-out branch tracks (a linked worktree publishes the
+        // remote its own branch knows); tags themselves are repository-wide.
+        const tags = await listTagNames(deps.exec, facts.toplevel);
+        if (!tags.includes(name))
+            return fail(400, `"${name}" is not a local tag`);
+        const choice = await resolvePushRemote(deps.exec, facts.toplevel);
+        if (!choice.ok)
+            return fail(400, choice.message);
+        const result = await pushTag(deps.exec, facts.toplevel, name, choice.remote);
+        const body = result;
+        return { status: 200, body };
+    }
+    catch (error) {
+        if (error instanceof GitError)
+            return gitFailure(error);
+        return fail(500, error instanceof Error ? error.message : String(error));
+    }
+}
 /**
  * POST /commit-files — the files one commit of the queried checkout changed.
  * The hash is verified server-side; unknown revisions answer 400.

package/lib/wire.d.ts

@@ -53,6 +53,10 @@ export declare const ROUTE_COMMIT = "/plugin/git-worktree/commit";
 export declare const ROUTE_LOG = "/plugin/git-worktree/log";
 /** POST ROUTE_PREFIX/commit-files — the files one commit changed. */
 export declare const ROUTE_COMMIT_FILES = "/plugin/git-worktree/commit-files";
+/** POST ROUTE_PREFIX/tag — create a tag at an existing commit. */
+export declare const ROUTE_TAG = "/plugin/git-worktree/tag";
+/** POST ROUTE_PREFIX/tag-push — push ONE existing local tag to its remote. */
+export declare const ROUTE_TAG_PUSH = "/plugin/git-worktree/tag-push";
 /** POST ROUTE_PREFIX/ai-commit-message — one-shot LLM commit message from
  * the staged diff (mounted only where the host provides the llm service). */
 export declare const ROUTE_AI_COMMIT_MESSAGE = "/plugin/git-worktree/ai-commit-message";
@@ -472,11 +476,57 @@ export interface LogBody {
     skip?: number;
     /** Optional starting ref (a branch name, `HEAD`, …); validated server-side. */
     ref?: string;
+    /** Walk every ref (branches + tags) instead of the checkout's HEAD — the
+     * history card's default view, which is what makes branches/merges visible.
+     * Ignored when `ref` is given. */
+    all?: boolean;
+    /** Committer-author substring/regex (`--author`); absent = every author. */
+    author?: string;
+    /** Lower bound on the commit date, epoch milliseconds (`--since`). */
+    since?: number;
+    /** Upper bound on the commit date, epoch milliseconds (`--until`). */
+    until?: number;
 }
 /** POST log response body. */
 export interface LogResult {
     commits: CommitEntry[];
 }
+/** POST tag request body. */
+export interface CreateTagBody {
+    /** Any directory inside the repository (tag refs are repository-wide). */
+    repoPath: string;
+    /** User-typed tag name, verbatim (git validates it). */
+    name: string;
+    /** The commit to tag (a full or abbreviated hash, validated server-side);
+     * absent tags the repository's current HEAD. */
+    target?: string;
+    /** Optional annotation message; non-empty creates an ANNOTATED tag. */
+    message?: string;
+}
+/** POST tag response body. */
+export interface CreateTagResult {
+    /** The tag created. */
+    tag: string;
+    /** The commit hash the tag points at. */
+    hash: string;
+}
+/** POST tag-push request body. */
+export interface PushTagBody {
+    /** Any directory inside the repository (tag refs are repository-wide). */
+    repoPath: string;
+    /** An EXISTING local tag name, verified server-side before any push. */
+    name: string;
+}
+/** POST tag-push response body. */
+export interface PushTagResult {
+    /** The tag that was the subject of the push. */
+    tag: string;
+    /** The remote the tag was pushed to (resolved server-side). */
+    remote: string;
+    /** False when the remote already carried this exact tag object — nothing
+     * was sent. True once the push command actually ran. */
+    pushed: boolean;
+}
 /** One file row of POST commit-files. */
 export interface CommitFileEntry {
     /** New path, relative to the repository root. */

package/lib/wire.js

@@ -53,6 +53,10 @@ export const ROUTE_COMMIT = `${ROUTE_PREFIX}/commit`;
 export const ROUTE_LOG = `${ROUTE_PREFIX}/log`;
 /** POST ROUTE_PREFIX/commit-files — the files one commit changed. */
 export const ROUTE_COMMIT_FILES = `${ROUTE_PREFIX}/commit-files`;
+/** POST ROUTE_PREFIX/tag — create a tag at an existing commit. */
+export const ROUTE_TAG = `${ROUTE_PREFIX}/tag`;
+/** POST ROUTE_PREFIX/tag-push — push ONE existing local tag to its remote. */
+export const ROUTE_TAG_PUSH = `${ROUTE_PREFIX}/tag-push`;
 /** POST ROUTE_PREFIX/ai-commit-message — one-shot LLM commit message from
  * the staged diff (mounted only where the host provides the llm service). */
 export const ROUTE_AI_COMMIT_MESSAGE = `${ROUTE_PREFIX}/ai-commit-message`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-git-branch-manage",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "提供 git 分支与 worktree 管理：输入框工具栏显示当前分支、可原地切换；支持 IDEA 风格分支选择器、远程分支检出、右键操作菜单（新建/重命名/删除/复制）、推送与更新当前分支，以及把分支隔离到独立 worktree 工作区，并管理其创建与删除。",
   "keywords": [
     "dsh",