@maccesar/aiskills 1.11.0 → 1.15.0

package/skills/stitch-showcase/scripts/slug_demangle.py

@@ -0,0 +1,209 @@
+"""
+slug_demangle.py — Reverses Stitch's accent stripping in screen filenames.
+
+Google Stitch replaces accented characters (á, é, í, ó, ú, ñ, ü) with `_`
+when exporting screens, so "Configuración" becomes "configuraci_n" and
+"Membresías" becomes "membres_as".
+
+This module exposes a single function `demangle_to_title(slug)` that infers
+the readable display title for a Stitch-style mangled slug, using a
+dictionary of common Spanish words with their accent positions.
+
+For slugs the dictionary doesn't cover, the user can still override the
+title explicitly via `Title | Description` in DESIGN.md.
+"""
+import re
+
+
+# Mangled → fixed (lowercase). Longer entries are applied first so that
+# composites like "men_m_s" beat the standalone "men_".
+WORD_REPLACEMENTS: dict[str, str] = {
+    # -ción / -sión nouns
+    "acci_n": "acción",
+    "aceptaci_n": "aceptación",
+    "activaci_n": "activación",
+    "actualizaci_n": "actualización",
+    "administraci_n": "administración",
+    "aplicaci_n": "aplicación",
+    "asignaci_n": "asignación",
+    "autenticaci_n": "autenticación",
+    "calificaci_n": "calificación",
+    "cancelaci_n": "cancelación",
+    "clasificaci_n": "clasificación",
+    "comunicaci_n": "comunicación",
+    "configuraci_n": "configuración",
+    "confirmaci_n": "confirmación",
+    "conexi_n": "conexión",
+    "creaci_n": "creación",
+    "descripci_n": "descripción",
+    "direcci_n": "dirección",
+    "discusi_n": "discusión",
+    "donaci_n": "donación",
+    "duraci_n": "duración",
+    "edici_n": "edición",
+    "educaci_n": "educación",
+    "elecci_n": "elección",
+    "evaluaci_n": "evaluación",
+    "exclusi_n": "exclusión",
+    "facturaci_n": "facturación",
+    "geolocalizaci_n": "geolocalización",
+    "habitaci_n": "habitación",
+    "identificaci_n": "identificación",
+    "informaci_n": "información",
+    "inscripci_n": "inscripción",
+    "instalaci_n": "instalación",
+    "introducci_n": "introducción",
+    "modificaci_n": "modificación",
+    "navegaci_n": "navegación",
+    "notificaci_n": "notificación",
+    "opci_n": "opción",
+    "operaci_n": "operación",
+    "organizaci_n": "organización",
+    "personalizaci_n": "personalización",
+    "posici_n": "posición",
+    "publicaci_n": "publicación",
+    "recuperaci_n": "recuperación",
+    "registraci_n": "registración",
+    "relaci_n": "relación",
+    "reservaci_n": "reservación",
+    "revisi_n": "revisión",
+    "secci_n": "sección",
+    "selecci_n": "selección",
+    "soluci_n": "solución",
+    "suscripci_n": "suscripción",
+    "transacci_n": "transacción",
+    "ubicaci_n": "ubicación",
+    "validaci_n": "validación",
+    "verificaci_n": "verificación",
+    "visualizaci_n": "visualización",
+    # composite phrases (must beat their standalone parts)
+    "men_m_s": "menú más",
+    "men_principal": "menú principal",
+    # standalone words with accents
+    "men_": "menú",
+    "caf_": "café",
+    "p_gina": "página",
+    "p_ginas": "páginas",
+    "art_culo": "artículo",
+    "art_culos": "artículos",
+    "categor_a": "categoría",
+    "categor_as": "categorías",
+    "membres_a": "membresía",
+    "membres_as": "membresías",
+    "pol_tica": "política",
+    "pol_ticas": "políticas",
+    "m_s": "más",
+    "qu_": "qué",
+    "c_mo": "cómo",
+    "d_a": "día",
+    "d_as": "días",
+    # words with ñ
+    "esc_ner": "escáner",
+    "rese_a": "reseña",
+    "rese_as": "reseñas",
+    "espa_a": "españa",
+    "espa_ol": "español",
+    "peque_o": "pequeño",
+    "peque_a": "pequeña",
+    "compa_a": "compañía",
+    "compa_as": "compañías",
+    "se_al": "señal",
+    "se_ales": "señales",
+    "ma_ana": "mañana",
+    "due_o": "dueño",
+    "ni_o": "niño",
+    "ni_a": "niña",
+    "a_o": "año",
+    "a_os": "años",
+    # other common standalone
+    "_xito": "éxito",
+    "_rea": "área",
+    "_reas": "áreas",
+    "_ltimo": "último",
+    "_ltima": "última",
+    "_nico": "único",
+    "_nica": "única",
+    "_til": "útil",
+    "_tiles": "útiles",
+    "tel_fono": "teléfono",
+    "n_mero": "número",
+    "n_meros": "números",
+    "c_digo": "código",
+    "c_digos": "códigos",
+    "m_dico": "médico",
+    "m_dica": "médica",
+    "p_blico": "público",
+    "p_blica": "pública",
+    "f_cil": "fácil",
+    "r_pido": "rápido",
+    "r_pida": "rápida",
+    "_ndice": "índice",
+    "_xitos": "éxitos",
+}
+
+
+def demangle_word(token: str) -> str:
+    """
+    Try to recover the accented form of a single mangled token (no separators).
+    Returns the token unchanged if no entry matches.
+    """
+    return WORD_REPLACEMENTS.get(token.lower(), token)
+
+
+def demangle_to_title(slug: str) -> str:
+    """
+    Convert a (possibly mangled) snake-case slug into a readable display title.
+
+    Examples:
+        "configuraci_n_oscuro" → "Configuración Oscuro"
+        "membres_as_y_pagos"   → "Membresías Y Pagos"
+        "home_screen"          → "Home Screen"
+        "men_m_s"              → "Menú Más"
+    """
+    if not slug:
+        return ""
+
+    s = slug.strip().lower()
+
+    # Apply dictionary replacements, longest first to handle composites correctly.
+    # We anchor each match to slug-token boundaries (start, end, or non-mangled `_`
+    # separator) so a short entry like "men_" does not eat into "menma".
+    for mangled in sorted(WORD_REPLACEMENTS.keys(), key=len, reverse=True):
+        fixed = WORD_REPLACEMENTS[mangled]
+        pattern = re.compile(
+            rf"(?:^|(?<=[^a-záéíóúñü\d]))"
+            rf"{re.escape(mangled)}"
+            rf"(?=$|[^a-záéíóúñü\d])",
+            re.IGNORECASE,
+        )
+        s = pattern.sub(fixed, s)
+
+    # Replace remaining separators and apply Title Case.
+    return s.replace("_", " ").replace("-", " ").title()
+
+
+def slug_to_title(slug: str) -> str:
+    """
+    Canonical slug → display title for the showcase pipeline.
+
+    Strips a leading numeric ordering prefix (``01_splash_screen`` →
+    ``splash_screen``) and then delegates to :func:`demangle_to_title`.
+    Falls back to ``slug.title()`` only in the edge case where the entire
+    slug is digits/underscores.
+
+    This is the single source of truth used by both ``parse_design_md`` and
+    ``build_showcase``.
+    """
+    if not slug:
+        return ""
+    stripped = re.sub(r"^[\d_]+", "", slug)
+    return demangle_to_title(stripped) or slug.title()
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) < 2:
+        print("Usage: python slug_demangle.py <slug>", file=sys.stderr)
+        sys.exit(1)
+    print(slug_to_title(sys.argv[1]))

package/skills/vscode-extension-dev/SKILL.md

@@ -1,34 +1,73 @@
 ---
 name: vscode-extension-dev
-description: Guide for building VS Code extensions from scratch. Use when the user is creating, scaffolding, designing, debugging, testing, bundling, or publishing a VS Code extension. Covers all major API patterns — TreeView, QuickPick, Webview, StatusBar, commands, configuration, SecretStorage, progress indicators, and esbuild bundling.
-when_to_use: >
-  - User wants to create a new VS Code extension
-  - User asks about VS Code extension APIs (TreeView, Webview, QuickPick, etc.)
-  - User needs help with package.json contributes, activationEvents, or keybindings
-  - User is debugging extension activation, disposables, or memory leaks
-  - User asks about bundling extensions with esbuild or webpack
-  - User wants to publish an extension to the VS Code Marketplace or Open VSX
-  - User asks about Webview CSP, nonce, or postMessage communication
-  - User asks about SecretStorage or credential management in extensions
-  - User needs help with extension testing (@vscode/test-electron)
-source: "VS Code Extension API documentation (https://code.visualstudio.com/api)"
-anti_hallucination_note: >
-  ALL guidance in this skill comes from the official VS Code Extension API docs
-  and established community patterns. Do NOT invent API methods, event names,
-  or configuration keys. If unsure whether an API exists, say so explicitly.
-  Always verify imports come from the 'vscode' module.
+description: 'Use when the user is creating, scaffolding, designing, debugging, testing, bundling, or publishing a VS Code extension. Covers TreeView, QuickPick, Webview, StatusBar, commands, configuration, SecretStorage, progress indicators, and esbuild bundling. Triggers: "create a VS Code extension", VS Code Extension APIs, package.json contributes/activationEvents/keybindings, debugging activation/disposables/memory leaks, bundling with esbuild/webpack, publishing to Marketplace or Open VSX, Webview CSP/nonce/postMessage, SecretStorage, extension testing (@vscode/test-electron).'
 ---
 
 # VS Code Extension Development Skill
 
 You are a VS Code extension development advisor. Base ALL guidance on the reference files below — not training data.
 
-## How to Use This Skill
+## Required workflow (read before responding)
 
-1. Read the relevant reference file(s) before answering
-2. Base ALL code on the reference content — not training data
-3. Use real TypeScript imports and correct `vscode` API signatures
-4. Do not invent API methods, events, or configuration keys not in the references
+The SKILL.md alone is an **index** of references. The detail you need
+to give accurate answers lives in the reference files. **Reading this
+SKILL.md is not enough.**
+
+### Step 1 — Open the relevant reference files
+
+| Task involves | Required reading |
+|---|---|
+| TreeView, TreeDataProvider, sidebar trees | [references/api-treeview.md](references/api-treeview.md) |
+| Webview Panel, CSP, postMessage, nonce | [references/api-webview.md](references/api-webview.md) |
+| QuickPick (simple or async with debounce) | [references/api-quickpick.md](references/api-quickpick.md) |
+| StatusBarItem, codicons, status bar UI | [references/api-statusbar.md](references/api-statusbar.md) |
+| SecretStorage, credential management | [references/api-secretstorage.md](references/api-secretstorage.md) |
+| withProgress, cancellation tokens | [references/api-progress.md](references/api-progress.md) |
+| FileSystemWatcher, Diagnostics, OutputChannel, ContextKeys, TextDocumentContentProvider, disposable lifecycle | [references/api-additional.md](references/api-additional.md) |
+| Activation events, project structure, layered architecture, testing | [references/architecture.md](references/architecture.md) |
+| `contributes`, `activationEvents`, `engines`, `scripts`, `keybindings`, esbuild config | [references/package-json-schema.md](references/package-json-schema.md) |
+| Marketplace publishing, vsce, Open VSX, CI/CD, `.vscodeignore`, versioning | [references/publishing.md](references/publishing.md) |
+| Language Server Protocol, `vscode-languageclient`, language servers | [references/lsp.md](references/lsp.md) |
+| Notebook serializers, controllers, renderers | [references/notebooks.md](references/notebooks.md) |
+| Debug Adapter Protocol, `DebugAdapterDescriptorFactory`, `DebugConfigurationProvider` | [references/debugger.md](references/debugger.md) |
+| Advanced testing — multi-suite `.vscode-test.mjs`, fixtures, mocking, CI, coverage | [references/testing.md](references/testing.md) |
+
+### Step 2 — Output contract
+
+Every API symbol, configuration key, command, or behavior you cite MUST
+be backed by a citation in the form:
+
+`[source: references/<file>.md]`
+
+Example: *"Push all subscriptions to `context.subscriptions` so they are disposed on deactivation [source: references/api-additional.md]"*
+
+### Step 3 — If you must answer from memory
+
+If you write a claim without having read the reference that backs it,
+prepend `FROM_MEMORY (unverified):` to that claim. Do not hide it.
+
+### Banned behaviors
+
+- ❌ Inventing API methods, event names, or configuration keys not in the references
+- ❌ Importing from anywhere other than the `'vscode'` module
+- ❌ Suggesting deprecated APIs (e.g. `vscode.workspace.rootPath`) without flagging them as deprecated
+- ❌ Marking the answer complete without listing which reference files you read
+
+## When to use
+
+- User wants to create a new VS Code extension
+- User asks about VS Code extension APIs (TreeView, Webview, QuickPick, etc.)
+- User needs help with package.json contributes, activationEvents, or keybindings
+- User is debugging extension activation, disposables, or memory leaks
+- User asks about bundling extensions with esbuild or webpack
+- User wants to publish an extension to the VS Code Marketplace or Open VSX
+- User asks about Webview CSP, nonce, or postMessage communication
+- User asks about SecretStorage or credential management in extensions
+- User needs help with extension testing (@vscode/test-electron)
+
+## Source
+
+VS Code Extension API documentation (https://code.visualstudio.com/api)
 
 ## Scaffolding Workflow
 
@@ -37,7 +76,7 @@ You are a VS Code extension development advisor. Base ALL guidance on the refere
 3. **Choose bundler**: esbuild (recommended) or webpack
 4. **Project structure** created — see `references/architecture.md` for layout
 5. **Configure** `package.json` — see `references/package-json-schema.md`
-6. **Implement** — see `references/api-patterns.md` for working examples
+6. **Implement** — pick the right reference from the Step 1 table (TreeView, Webview, QuickPick, StatusBar, SecretStorage, withProgress, or api-additional)
 7. **Test** — see `references/architecture.md` for testing strategy
 8. **Publish** — see `references/publishing.md` for full workflow
 
@@ -65,24 +104,24 @@ You are a VS Code extension development advisor. Base ALL guidance on the refere
 - Push ALL subscriptions to `context.subscriptions` in `activate()`
 - Use `deactivate()` only for async cleanup (closing connections, stopping servers)
 - Never rely on garbage collection — always dispose explicitly
-- See `references/api-patterns.md` for the cleanup pattern
+- See `references/api-additional.md` for the cleanup pattern
 
 ### withProgress for Async Operations
 - Use `ProgressLocation.Notification` for user-facing tasks
 - Use `ProgressLocation.Window` for status bar progress
 - Support cancellation via `CancellationToken`
-- See `references/api-patterns.md` for working examples
+- See `references/api-progress.md` for working examples
 
 ### SecretStorage for Credentials
 - Use `context.secrets` (SecretStorage API) — never store tokens in settings
 - Fires `onDidChange` event when secrets change
-- See `references/api-patterns.md` for the credential manager pattern
+- See `references/api-secretstorage.md` for the credential manager pattern
 
 ### Webview CSP and PostMessage
 - Always set a Content Security Policy with nonce
 - Use `webview.asWebviewUri()` for local resources
 - Bidirectional communication via `postMessage` / `onDidReceiveMessage`
-- See `references/api-patterns.md` for the full Webview pattern
+- See `references/api-webview.md` for the full Webview pattern
 
 ### esbuild Bundling
 - Bundle extension into a single file for faster activation
@@ -91,20 +130,30 @@ You are a VS Code extension development advisor. Base ALL guidance on the refere
 
 ## Reference Files
 
-| File                                | Topics                                                              |
-| ----------------------------------- | ------------------------------------------------------------------- |
-| `references/package-json-schema.md` | contributes, activationEvents, engines, scripts, devDependencies    |
-| `references/api-patterns.md`        | TreeView, Webview, QuickPick, StatusBar, SecretStorage, withProgress |
-| `references/architecture.md`        | Project structure, layered architecture, testing strategy            |
-| `references/publishing.md`          | vsce, .vscodeignore, CI/CD, Open VSX, versioning                    |
+| File                                  | Topics                                                                             |
+| ------------------------------------- | ---------------------------------------------------------------------------------- |
+| `references/api-treeview.md`          | TreeDataProvider, TreeView registration                                            |
+| `references/api-webview.md`           | Webview Panel, CSP/nonce, postMessage, asWebviewUri                                |
+| `references/api-quickpick.md`         | Simple and async QuickPick with debounced search                                   |
+| `references/api-statusbar.md`         | StatusBarItem, codicons, dynamic updates                                           |
+| `references/api-secretstorage.md`     | Credential manager pattern, onDidChange                                            |
+| `references/api-progress.md`          | withProgress (Notification + Window), cancellation tokens                          |
+| `references/api-additional.md`        | FileSystemWatcher, Disposable cleanup, Diagnostics, OutputChannel, ContextKeys, TextDocumentContentProvider |
+| `references/architecture.md`          | Project structure, layered architecture, testing strategy                          |
+| `references/package-json-schema.md`   | contributes, activationEvents, engines, scripts, devDependencies                   |
+| `references/publishing.md`            | vsce, .vscodeignore, CI/CD, Open VSX, versioning                                  |
+| `references/lsp.md`                   | LSP client setup, server lifecycle, capabilities, diagnostics                      |
+| `references/notebooks.md`             | Notebook serializers, controllers, renderers, output mime types                    |
+| `references/debugger.md`              | DAP: descriptor factory, configuration provider, adapter lifecycle                 |
+| `references/testing.md`               | Multi-suite test config, workspace fixtures, mocking `vscode`, CI, coverage        |
 
 ## Anti-Patterns to Avoid
 
-- Using `*` activation event in production (activates on every VS Code start)
-- Storing secrets in `configuration` instead of `SecretStorage`
-- Forgetting to dispose subscriptions (causes memory leaks)
-- Missing CSP in Webviews (security vulnerability)
-- Bundling `node_modules` instead of using esbuild/webpack
-- Using synchronous file I/O in the extension host (blocks the UI)
-- Registering commands without corresponding `contributes.commands` entries
-- Hardcoding `vscode.workspace.rootPath` (deprecated — use `workspaceFolders`)
+- Using `*` activation event in production (activates on every VS Code start) [source: references/package-json-schema.md]
+- Storing secrets in `configuration` instead of `SecretStorage` [source: references/api-secretstorage.md]
+- Forgetting to dispose subscriptions (causes memory leaks) [source: references/api-additional.md]
+- Missing CSP in Webviews (security vulnerability) [source: references/api-webview.md]
+- Bundling `node_modules` instead of using esbuild/webpack [source: references/package-json-schema.md]
+- Using synchronous file I/O in the extension host (blocks the UI) [source: references/architecture.md]
+- Registering commands without corresponding `contributes.commands` entries [source: references/package-json-schema.md]
+- Hardcoding `vscode.workspace.rootPath` (deprecated — use `workspaceFolders`) [source: references/architecture.md]

package/skills/vscode-extension-dev/references/api-additional.md

@@ -0,0 +1,168 @@
+# Additional API Patterns
+
+Lower-frequency patterns that complement the core UI components.
+
+## FileSystemWatcher
+
+React to file changes in the workspace.
+
+```typescript
+export function activate(context: vscode.ExtensionContext) {
+  const watcher = vscode.workspace.createFileSystemWatcher(
+    '**/*.json',     // glob pattern
+    false,           // ignoreCreateEvents
+    false,           // ignoreChangeEvents
+    false,           // ignoreDeleteEvents
+  );
+
+  context.subscriptions.push(
+    watcher,
+    watcher.onDidCreate((uri) => {
+      console.log(`Created: ${uri.fsPath}`);
+    }),
+    watcher.onDidChange((uri) => {
+      console.log(`Changed: ${uri.fsPath}`);
+    }),
+    watcher.onDidDelete((uri) => {
+      console.log(`Deleted: ${uri.fsPath}`);
+    }),
+  );
+}
+```
+
+## Disposable Cleanup Pattern
+
+The standard pattern for managing extension lifecycle.
+
+```typescript
+import * as vscode from 'vscode';
+
+let outputChannel: vscode.OutputChannel | undefined;
+
+export function activate(context: vscode.ExtensionContext) {
+  // Output channel for logging
+  outputChannel = vscode.window.createOutputChannel('My Extension');
+  context.subscriptions.push(outputChannel);
+
+  // All registrations go into context.subscriptions
+  context.subscriptions.push(
+    vscode.commands.registerCommand('myExt.run', run),
+    vscode.workspace.onDidSaveTextDocument(onDocSaved),
+    vscode.window.onDidChangeActiveTextEditor(onEditorChanged),
+  );
+
+  outputChannel.appendLine('Extension activated');
+}
+
+export function deactivate(): void {
+  // Only needed for async cleanup like:
+  // - Closing network connections
+  // - Stopping child processes
+  // - Flushing buffers
+  // Disposables in context.subscriptions are auto-disposed.
+}
+
+function run(): void {
+  outputChannel?.appendLine('Command executed');
+}
+
+function onDocSaved(doc: vscode.TextDocument): void {
+  outputChannel?.appendLine(`Saved: ${doc.fileName}`);
+}
+
+function onEditorChanged(editor: vscode.TextEditor | undefined): void {
+  outputChannel?.appendLine(`Active editor: ${editor?.document.fileName ?? 'none'}`);
+}
+```
+
+## Diagnostic Collection
+
+Report problems (errors, warnings) in the Problems panel.
+
+```typescript
+const diagnostics = vscode.languages.createDiagnosticCollection('myExt');
+context.subscriptions.push(diagnostics);
+
+function validateDocument(doc: vscode.TextDocument): void {
+  const issues: vscode.Diagnostic[] = [];
+
+  for (let i = 0; i < doc.lineCount; i++) {
+    const line = doc.lineAt(i);
+    if (line.text.includes('TODO')) {
+      issues.push(
+        new vscode.Diagnostic(
+          line.range,
+          'TODO comment found',
+          vscode.DiagnosticSeverity.Warning,
+        ),
+      );
+    }
+  }
+
+  diagnostics.set(doc.uri, issues);
+}
+```
+
+## Output Channel and Logging
+
+```typescript
+// Simple output channel
+const output = vscode.window.createOutputChannel('My Extension');
+output.appendLine('Info message');
+output.show(true); // true = preserve focus
+
+// Log output channel (structured, with log levels — VS Code 1.74+)
+const log = vscode.window.createOutputChannel('My Extension', { log: true });
+log.info('Started');
+log.warn('Something looks off');
+log.error('Something failed', new Error('details'));
+log.debug('Debug data', { key: 'value' });
+```
+
+## Context Keys (When Clauses)
+
+Set custom context keys to control menu/command visibility.
+
+```typescript
+// Set a context key
+vscode.commands.executeCommand('setContext', 'myExt.isConnected', true);
+
+// Use in package.json when clauses:
+// "when": "myExt.isConnected"
+// "when": "myExt.isConnected && editorLangId == typescript"
+
+// Clear it
+vscode.commands.executeCommand('setContext', 'myExt.isConnected', false);
+```
+
+## TextDocumentContentProvider
+
+Provide virtual read-only documents.
+
+```typescript
+class MyContentProvider implements vscode.TextDocumentContentProvider {
+  private _onDidChange = new vscode.EventEmitter<vscode.Uri>();
+  readonly onDidChange = this._onDidChange.event;
+
+  provideTextDocumentContent(uri: vscode.Uri): string {
+    const query = new URLSearchParams(uri.query);
+    const id = query.get('id') ?? 'unknown';
+    return `Content for: ${id}\nGenerated at: ${new Date().toISOString()}`;
+  }
+
+  refresh(uri: vscode.Uri): void {
+    this._onDidChange.fire(uri);
+  }
+}
+
+// Register
+const provider = new MyContentProvider();
+context.subscriptions.push(
+  vscode.workspace.registerTextDocumentContentProvider('myScheme', provider),
+);
+
+// Open a virtual document
+const uri = vscode.Uri.parse('myScheme:item?id=123');
+const doc = await vscode.workspace.openTextDocument(uri);
+await vscode.window.showTextDocument(doc);
+```

package/skills/vscode-extension-dev/references/api-progress.md

@@ -0,0 +1,55 @@
+# withProgress
+
+Show progress for long-running operations.
+
+## Notification Progress
+
+```typescript
+async function longRunningTask(): Promise<void> {
+  await vscode.window.withProgress(
+    {
+      location: vscode.ProgressLocation.Notification,
+      title: 'Processing items',
+      cancellable: true,
+    },
+    async (progress, token) => {
+      const items = await getItems();
+      const total = items.length;
+
+      for (let i = 0; i < total; i++) {
+        // Check for cancellation
+        if (token.isCancellationRequested) {
+          vscode.window.showWarningMessage('Operation cancelled.');
+          return;
+        }
+
+        progress.report({
+          increment: 100 / total,
+          message: `(${i + 1}/${total}) ${items[i].name}`,
+        });
+
+        await processItem(items[i]);
+      }
+
+      vscode.window.showInformationMessage(`Processed ${total} items.`);
+    },
+  );
+}
+```
+
+## Status Bar Progress
+
+```typescript
+await vscode.window.withProgress(
+  {
+    location: vscode.ProgressLocation.Window,
+    title: 'Indexing files...',
+  },
+  async (progress) => {
+    progress.report({ message: 'scanning...' });
+    await scanFiles();
+    progress.report({ message: 'building index...' });
+    await buildIndex();
+  },
+);
+```