Actifsource Tools

A VS Code extension that bundles the day-to-day work with GitLab and Claude Code: time tracking on issues, a GitLab MCP server for Claude Code, management of skills & agents, and AI-assisted code reviews — all sharing one GitLab token and a connection lamp in the status bar.

Contents

• What can the extension do?
• Quick start
• GitLab personal access token
• Features in detail
  • 1. Time tracking
  • 2. GitLab MCP for Claude Code
  • 3. Manage skills & agents
  • 4. Code reviews
  • 5. To-Do board
  • 6. Claude session usage
  • 7. Feature tasks
  • 8. Pipeline / CI status
  • 9. Agent Office
  • 10. Task Runner
  • 11. TODO List (code comments)
  • Status bar
• Settings
• Commands
• Requirements

What can the extension do?

Quick start

1. Set the GitLab URL: Settings → actifsourceTools.gitlabUrl, e.g. https://gitlab.example.com.
2. Set the token: Command Palette (Ctrl+Shift+P) → Actifsource Tools: Set Personal Access Token (scope api, see below).
3. Open the panel: Actifsource Tools: Open (or click the green dot in the status bar).
4. (optional) Enable MCP for Claude: Actifsource Tools: Enable GitLab MCP for Claude Code.

GitLab personal access token

The extension both reads and writes to GitLab (creating/deleting timelogs, posting review comments). Therefore:

• Scope: api (full read/write). read_api is not enough once times are synced or reviews are posted.
• Account role: at least Reporter (issues + time + comments), Developer recommended for the full MR review workflow.
• The token is stored only in vscode.SecretStorage (on Windows via DPAPI) — never in settings.json or ~/.claude.json.

Create it in GitLab: User Settings → Access Tokens → scope api.

Features in detail

1. Time tracking

• Issue list with sections: pinned, GitLab — assigned to me, local, and optionally project/group (see defaultProjectId / defaultGroupId).
• Issue search: typing filters the loaded issues (title, ticket id #258/258, Jira key); a "🌐 Search globally" entry in the results extends the search server-side across all enabled GitLab and Jira accounts — including issues assigned to other users and closed issues (struck through, sorted last). Exact Jira keys (PROJ-123) are found globally too.
• Exactly one active timer that survives webview and VS Code restarts.
• Calendar (day/week/month): create/edit entries via context menu, move them by drag; 24-hour axis.
• Traffic-light dot per entry: 🔴 not synced · 🟡 changed, not synced yet · 🟢 synced.
• Sync sends each booking as a GitLab timelog (GraphQL timelogCreate / timelogDelete) — one entry = one timelog, with no negative correction rows in the time-tracking report. Editing the same entry multiple times is collapsed into a single sync (no duplicates).
• Revert discards all pending changes locally after a confirmation: new entries are deleted, edited entries return to their last synced state (Discard change), deleted entries are restored. Nothing is sent to a server; already-synced bookings are not touched.
• Local issues (L:<n>): purely local, machine-global issues with no GitLab link — bookable in the calendar, pinnable; "synced" into a global file.
• Transfer booked time: right-click a local issue to move all of its booked time onto a picked ticket (GitLab, Jira or another local issue). Nothing is sent to a server automatically — the retargeted entries land in the pending queue and are booked on the next manual Sync. The local issue is kept (empty); blocked while a timer runs on it.
• Month report: a monthly timesheet view (tickets × days with per-day, per-ticket and grand totals) next to the calendar. Data is fetched from the server per month, so closed issues are included; the calendar shows the same server-backed history for past months as read-only entries.
• Clickable issue ids: the ticket id in the calendar, the month report and the issue list opens the ticket in the browser (GitLab/Jira; local issues have no URL).
• Issue agent actions: right-click a GitLab/Jira issue to run Claude Code on it — Refine (work out the spec), Plan (work out the implementation plan), Implement (autonomous subagent: branch, code, verify, commit — optionally in a git worktree) and Ask, each in the terminal or the Claude Code view.
• View another user (read-only): shows their assigned issues and their logged time — no editing/booking. The user search spans all enabled GitLab and Jira accounts.

Jira time tracking (worklogs)

The same booking flow as GitLab, but for Jira Cloud — entries sync as Jira worklogs.

• Configure actifsourceTools.jira.url (e.g. https://your-site.atlassian.net) and actifsourceTools.jira.email, then run Actifsource Tools: Set Jira API Token with a token from id.atlassian.com (stored in SecretStorage). Optional: jira.defaultProjectKey, jira.jql.
• Jira issues appear in a "Jira assigned to me" section (assignee = currentUser(), plus the optional project/JQL) and book time in the same calendar as GitLab/local entries.
• Sync creates/deletes Jira worklogs (one entry = one worklog); editing replaces the worklog. Reconcile pulls in your own worklogs and removes locally-deleted ones.
• Only your own worklogs are touched (matched by Atlassian account id).

2. GitLab MCP for Claude Code

Enables the GitLab MCP server (@zereight/mcp-gitlab) for Claude Code in the integrated terminal — so Claude can work with GitLab directly (issues, MRs, comments …).

• The command Actifsource Tools: Enable GitLab MCP for Claude Code writes a gitlab entry into the user-global ~/.claude.json and injects the token as an environment variable into new integrated terminals.
• Reuse: uses the same token and URL as time tracking — no second token needed. GITLAB_API_URL is derived from gitlabUrl.
• Secure: ~/.claude.json only contains the reference ${GITLAB_PAT}, never the value.
• After enabling: open a new integrated terminal, start claude, run /mcp.
• Actifsource Tools: GitLab MCP Status shows a checklist (token, entry, npx on PATH …).

Atlassian (Jira/Confluence): Actifsource Tools: Enable Atlassian MCP for Claude Code adds the official Atlassian remote MCP server as a native SSE entry ({ "type": "sse", "url": "https://mcp.atlassian.com/v1/sse" }) to ~/.claude.json. Authentication is OAuth 2.1 — a browser window opens in Claude Code on first use; no token is stored or configured. It targets your Atlassian Cloud site(s) via the hosted gateway (not your site URL directly). Enable/disable/status are also in the green-dot menu.

More MCP servers, each with enable/disable/status commands and green-dot menu entries: GitHub MCP (token-based, used by the GitHub PR review), Actifsource MCP (local server, URL/port configurable) and Playwright MCP (browser automation, optional CDP endpoint to attach to a running browser). Actifsource Tools: MCP Status (all servers) shows one combined checklist.

3. Manage skills & agents

A dedicated page (Actifsource Tools: Manage Skills & Agents) to enable/disable Claude Code skills and agents — bundled templates and your own files under ~/.claude/.

• Enable moves/writes into the live directory (~/.claude/agents/<name>.md or ~/.claude/skills/<name>/) that Claude Code scans at session start.
• Disable moves it into a disabled store — never deleted, fully reversible.
• Visible before enabling: an agent's requested tools/model, whether a skill ships scripts/, and an origin badge (bundled/user).
• A hand-authored file of the same name is never overwritten (conflict is shown).
• With actifsourceTools.autoUpdateAgentAndSkill (default on), managed copies are refreshed from the latest bundled version at startup.
• The page also manages CLAUDE.md chapters (appended between marker comments to ~/.claude/CLAUDE.md) and status-line scripts (bundled ai/statusLine/*, copied to ~/.claude/ and wired into ~/.claude/settings.json).

Remote sources (skills, agents & plugins from GitHub)

The page also lists artifacts from GitHub repositories — configured in actifsourceTools.remoteSources or added via the "Add remote source…" wizard:

• Remote skills and agents appear alongside the local ones and can be installed, updated and uninstalled per card. Installs are pinned to the resolved commit SHA and are never auto-updated — an Update button appears when the source moved on.
• Plugins get their own section and are installed through the claude CLI (claude plugin install). Plugin installs and skills shipping scripts/ require an explicit confirmation.
• A Sources panel lists every source with an enable/disable checkbox — the extension bundle first (unchecking it hides bundled items you haven't installed yet; setting actifsourceTools.bundledSourceEnabled), then the remotes, then Add remote source…; collapsed via a Show more / Show less divider. Bundled default sources and plugins ship with the extension. Private repositories are accessed with a registered GitHub account's token (public ones work anonymously).
• Installed items always stay visible, even when their source is unchecked — installed skills, agents and plugins remain listed and can still be toggled or uninstalled.

4. Code reviews

The page Actifsource Tools: Review a Merge Request starts a Claude review in a new integrated terminal — two clearly separated variants:

• 🔵 Merge Request / Pull Request: one smart URL field accepts GitLab MR and GitHub PR URLs and picks the matching agent (review-gitlab-mr / review-github-pr), then Review in Chat, Draft for Review, or Post directly. GitHub reviews use GitHub's pending-review model (inline comments inside a review).
• 🟣 Local (review-local): reviews the current branch against main, results in chat only — nothing is posted, no token/MCP required.

The required review agent must be enabled; if it is not, the page blocks the review and offers to enable it. MR reviews additionally require MCP and a token to be ready.

5. To-Do board

A standalone Kanban page (Actifsource Tools: Open To-Do Page) — separate from issues and the timer, for quick personal tasks.

• Columns with custom names: add, rename, delete and reorder (◀▶).
• Cards = title + optional due date + notes, with 5 fixed colors; drag&drop between columns and to reorder. Done (checkbox, strikethrough) and archived are separate states; a top-bar toggle switches the whole board between Active and Archived views.
• Due-date reminder in the status bar: while any active to-do is due today or overdue, a 🔔 <count> item appears (tooltip lists them, click opens the board), tinted by the highest-priority color among them.
• Ticket references: a card can reference 0–n tickets (GitLab/Jira/local) as clickable chips, with navigation in both directions (ticket → board, board → ticket) and a Create To-Do from Ticket command.
• Saved workspace context (💾): a card can carry at most one snapshot of your workspace — open editors, cursor positions, breakpoints and branch metadata — restored explicitly via commands (with or without branch switch). Nothing is saved or restored automatically, and the working tree is never touched (no stash, no commit).
• Stored machine-globally in todo-data.json; the folder is overridable via actifsourceTools.todoStorageDirectory.

6. Claude session usage

A standalone page (Actifsource Tools: Claude Session Usage) giving the cross-session, historical view that Claude Code's native /usage (current session only) doesn't provide.

• Reads Claude Code's own local transcripts (~/.claude/projects/**/*.jsonl) — not the extension's data — and lists every session grouped by project.
• Per session: token usage (input / output / cache-write / cache-read, per model), duration and message count, plus an estimated USD cost.
• Cost is an estimate. Because you are typically on a subscription, the $ figure is hypothetical "as-if-API"; tokens are shown primary, $ small. Pricing is fetched live from Anthropic's public pricing page (toggle actifsourceTools.claudeSessionUsage.fetchLivePricing) with a built-in fallback.
• Right-click a session to copy a context link (a prompt pointing Claude at that transcript) or resume the session in a terminal (claude --resume).

7. Feature tasks

A standalone board (Actifsource Tools: Feature Tasks) that visualizes the Claude Code feature-workflow task registry (.claude/feature-tasks.json) — the plan → review → background-implementation queue.

• Queue columns: one column per running task, with queued tasks stacked under the task they wait on; tasks with no running blocker collect in a "Waiting to run" column.
• Dependencies drawn as arrows / chips ("waits for" / "blocks"), and file conflicts between a queued task and its blockers highlighted in red.
• Each card shows its execution mode (workspace / worktree / chat) and, when available, the session channel title; collapsed by default, running cards show a progress strip.
• Finished (3 newest) + collapsible History; delete finished tasks or "Clear finished". The file is polled every 5 s while visible and never modified except by explicit deletes. A banner warns if the feature workflow isn't set up.

8. Pipeline / CI status

A status bar item showing the newest GitLab pipeline or GitHub Actions workflow run of the branch checked out in the workspace — no extra configuration: the repo's git remote is matched by host against your registered GitLab/GitHub accounts.

• At a glance: icon + pipeline number per state (running with job progress like test 2/5, passed, failed with red background, pending, canceled, manual action with yellow background, CI: none when the branch never ran a pipeline). The tooltip lists all stages/jobs with status and duration.
• Click menu: open the pipeline in the browser, show jobs and view a job log inside VS Code, retry failed jobs, cancel a running pipeline, refresh, and jump to older pipelines of the branch. Actions only appear when they make sense in the current state.
• Notifications: when one of your own pipelines fails (trigger user = token owner), a warning toast offers Show Log, Analyze with Claude and Ignore — at most once per pipeline. An optional success toast (pipelineStatus.notifyOnSuccess, default off) reports a previously running pipeline turning green.
• Analyze with Claude: fetches the failed jobs' logs (trimmed to the relevant tail), saves them to temp files and starts Claude Code in a terminal with the pipeline context — goal: a clear root cause and a concrete fix suggestion. Works best with the GitLab/GitHub MCP enabled (the action offers the setup if it isn't).
• Polling: fast while a pipeline is running (default 10 s), slow otherwise (default 60 s), immediate refresh on branch switch; both intervals are settings. Connection problems degrade silently to an "unavailable" state — never error popups.

9. Agent Office

A pixel-art office (Actifsource Tools: Agent Office) that visualizes live Claude Code subagent activity of the current workspace — read from the local session transcripts under ~/.claude/projects/, no API calls.

• The coordinator (your main Claude session) sits at the top desk; every subagent walks in through the door and takes a seat: 5 fixed workstations first, then the meeting table, then standing room around it (at most 40 figures are drawn, the rest are counted in the top bar).
• While working, a figure "types" with a speech bubble showing its current tool call (📖 file.ts, 🔍 "pattern", 💻 build, …); finished agents carry a folder to the coordinator, hand it over ("✔ done!") and leave through the door.
• Ambient behavior: stalled agents fetch a coffee, thinking agents step to the whiteboard, writing agents visit the printer (one per spot, with cooldowns). The idle coordinator takes coffee/printer breaks and waters the plants — and runs back to his desk the moment work starts.
• Detects direct agents, workflow-tool runs and git-worktree agents; a session picker covers the recent sessions of the workspace. Click a figure for task, state, tool calls, tokens and an Open transcript button.

10. Task Runner

Up to five workspace tasks on global keybindings — for the "rebuild" reflex without leaving the keyboard, wherever the focus is (editor, terminal, webview, explorer).

• Assign tasks on the Task Runner page (Actifsource Tools: Task Runner, also in the lamp menu): one row per slot with the default keybinding, a task input with suggestions, and Run/Clear buttons. Values are stored in the workspace settings (actifsourceTools.taskRunner.task1 … task5).
• Default shortcuts: Run Task 1 F7, 2 Ctrl+F7, 3 Shift+F7, 4 Ctrl+Shift+F7, 5 Alt+F7 (mac: Cmd instead of Ctrl). Pressing a shortcut again while its task still runs terminates and restarts it.
• While a slot is empty its shortcut is inactive and the keys keep their normal binding.
• A previously configured buildTask.name is migrated to Run Task 1 automatically.

11. TODO List (code comments)

A tree view in the bottom panel (next to Terminal/Problems) listing every tagged comment of the workspace — not to be confused with the To-Do board, which holds your own cards.

• Open it via the lamp menu → TODO List (command Actifsource Tools: TODO List). The tab is not shown until you ask for it; Hide TODO List in the view's … menu removes it again.
• Only active while visible. Scanning, file watching and blame run exclusively while the TODOS tab is showing; switch to Terminal and the feature stops completely. On re-show it reconciles the index (only changed files are re-read), so nothing flickers.
• Live updates: a TODO you type appears after ~300 ms, a deleted one disappears; branch switches and external edits are picked up through file watchers. The cold start uses the ripgrep bundled with VS Code to find candidate files and falls back to VS Code's own file search when rg is unavailable — silently.
• Comment-aware: only tags inside comments count (TODO, TODO:, TODO(name):); a "TODO" in a string or todoStore in code is ignored. Comment syntax comes from the installed language definitions.
• Group by file (default) or by tag; click an item to jump to the line; right-click to copy it or reveal the file in the Explorer.
• Show authors ($(person)) annotates every item with the last editor of its line from git blame (-w -M -C, unsaved buffers included); uncommitted or untracked lines show as you (uncommitted).
• Filter by author… ($(filter)) offers a multi-select over exactly the author names blame produced for the listed TODOs — plus a Me shortcut when git config user.email matches some of them. The active filter is shown in the view title; items whose author is not yet known stay visible until blame catches up.
• Built-in tags are TODO, FIXME, HACK; add your own via actifsourceTools.codeTodos.additionalTags (e.g. NOTE, XXX).

Status bar

On the left the Tracker item (active timer / pinned issues to start one), next to it "● ToolTime" with a connection lamp:

• ⚪ grey = not configured · 🔴 red = connection failed · 🟢 green = connected.
• Clicking the dot opens a menu: Time Tracker page, To-Do page, TODO List, Claude session usage, Feature tasks, Agent Office, Task Runner, Review, Skills & Agents, MCP toggles, accounts, settings.
• Next to it the CI item with the current branch's pipeline status (see Pipeline / CI status); click it for pipeline actions.
• Right of the tracker the Claude usage item (5h 39% · 7d 27%) with Claude Code's session and weekly rate-limit usage; turns red above 80%, click refreshes. Requires Claude Code credentials on this machine; disable via claudeUsage.enabled.

Settings

All under the prefix actifsourceTools.:

Commands

All in the Command Palette under "Actifsource Tools: …":

Requirements

• VS Code ≥ 1.85.
• GitLab (self-hosted or gitlab.com) with a PAT (scope api).
• For MCP/reviews: Claude Code (CLI) installed and on PATH, plus Node.js/npx (the MCP server runs via npx @zereight/mcp-gitlab).