Manifest cross-reference

This inventory ties every entry in package.json that the source must honor to the place in src/ that honors it: commands, menus, settings, context keys, command re-entry, views, and files. Phase 0 of the refactor plan takes it before anything moves, so that splitting src/extension.ts cannot silently stop registering a command, reading a setting, or setting a context key. It was taken at dev 1805a01, and every path:line below is 1-based at that commit, except in §6’s editor panels and sidebar views, which are as of the end of Phase 6 (030ee64).

No other section has been refreshed since. Phase 5 moved what src/extension.ts registered into src/composition/ and src/ui/commands/<feature>/register.ts, and Phase 6 rewrote every file under src/ui/webview/, so the src/extension.ts and src/ui/webview/ lines that sections 1 to 5, 7, and 8 cite describe 1805a01 only, and the code is found now by the command id, setting, or key each row names. A full refresh is out of reach for the end of Phase 6, so those sections stand as of their date.

Summary

The source reads 73 distinct deckard.* settings, which are exactly the 73 declared; the plan’s 77 matches no count of distinct keys, and 77 is the number of affectsConfiguration calls. The correct context-key count is 19 keys that Deckard sets (16 in when clauses and 3 only in walkthrough onContext: events) plus 5 config.deckard.* keys; the four deckard.* tokens after view == are view ids, not context keys. Nine keys are set by a literal setContext call; a grep for 'setContext', 'deckard. on one line finds seven, because two calls span lines. 18 is the number of distinct ids in single-line literal calls; counting calls that span lines gives 21, and counting constants, template strings, lookup maps, and command runners gives 39.

No setting is read without being declared, no declared setting goes unread, and every context key in a when clause has a setter. The behavior questions this inventory raises are gathered in Behavior questions.

Conventions

• A path without a folder prefix is under src/. Test paths are written in full.
• For a call that spans lines, the line given is the one that holds the call’s name: registerCommand(, executeCommand(, or .get and its kin.
• A row reached through a helper gives the caller’s line, and names the helper.
• package.json:N is the line that holds the entry’s id.

1. Commands

package.json contributes 96 commands. The source registers 102, all through vscode.commands.registerCommand in src/extension.ts: one at line 219 and the other 101 inside the context.subscriptions.push(...) blocks between lines 690 and 1267. No registration is conditional. No source uses registerTextEditorCommand. Every contributed command is registered, and six registered ids are not contributed.

Registered but not contributed

These six ids must keep being registered by their exact names after the split. Nothing in package.json names them, so no manifest check will catch their loss.

Contributed commands

“Registered at” is the line of the registerCommand( call. “Hidden from palette” means commandPalette gives it "when": "false"; “palette-gated” means it gives another when.

2. Menus and keybindings

Every command id that a menu or a keybinding names is contributed and registered. Both submenus are declared and have menus of their own.

That is 125 command entries and 2 submenu entries across ten menus, plus 10 keybindings: 135 command references, none unresolved. The submenus are declared at package.json:731 (deckard.editor.context) and package.json:735 (deckard.explorer.context).

Command links in package.json text

Walkthrough steps, viewsWelcome contents, and setting descriptions link commands as command: URIs. There are 20 links to 17 ids. Sixteen ids are contributed. deckard.agenda.focus is not a Deckard command: VS Code generates it from the view id deckard.agenda, so renaming that view breaks the link.

The walkthrough’s onCommand: completion events name seven ids: deckard.createDailyNote, deckard.createSampleWorkspace, deckard.capture, deckard.showDashboard, deckard.searchWorkspace, deckard.search, and deckard.chooseTheme. All seven are registered.

3. Settings

contributes.configuration declares 73 properties in seven titled groups. The source reads all 73 through get or inspect, and it reads no deckard.* key that is not declared. No declared setting is dead.

The scan found 221 calls: 133 get, 8 inspect, 3 update, and 77 affectsConfiguration. Writes through writeSetting (ui/commands/settings.ts:19) and target lookups through settingTarget (ui/commands/settings.ts:58) are credited to their callers in the table below.

Keys read without a literal key

Five calls read a key that is not a literal at the call. Each resolves to declared settings.

Three more calls read a literal key through a configuration whose section is not a literal at the call. ui/commands/taskActions.ts:592 is readTaskMetadataFormat(configuration), and all 15 callers pass a deckard configuration. core/workspace/scanner.ts:286, 290, 399, 412, 428, 433, 439, 445, and 451 read through the private getConfiguration() at core/workspace/scanner.ts:558, which returns the deckard section. core/workspace/scanner.ts:551 reads exclude from three sections in turn: deckard, files, and search.

Keys outside deckard.*

Change listeners on a section prefix

These affectsConfiguration calls name a section rather than a setting, so they cover every setting under it. A split that narrows one of them to named keys changes which edits refresh the view.

Declared settings

“Reads” are get and inspect calls, including inspect through settingTarget, settingPlace (ui/commands/parking.ts:273), and zenModeTarget (ui/webview/zenMode.ts:30). “Writes” are update calls, including those through writeSetting. “Listeners” are affectsConfiguration calls that name the key; a prefix listener above may also cover it. Paths in this table are written from the repository root.

deckard.parseInlineTags carries a markdownDeprecationMessage (package.json:1838) and is still read in three places. The message says a false value is read as heading, so the reads are deliberate.

4. Context keys

The 134 when clauses are 59 in commandPalette, 64 in the other nine menus, 7 in keybindings, 2 in viewsWelcome, and 2 in languageModelTools. No command uses enablement, and no view has a when. The walkthrough’s completion events add three onContext: keys.

Keys Deckard sets

Every key below has at least one setter. setContext goes through vscode.commands.executeCommand('setContext', key, value) in every case.

These 19 keys account for 56 of the when clauses. Nine are set by a literal key: hasNotes, hasTags, hasTasks, canUndo, excludedFolders, parkedNotes, parkedFolders, agendaFiltered, and agendaQuerySet. The other ten go through a constant, a helper, or the ActiveNoteContext ledger.

Two readers outside package.json name these keys as text. EDITOR_CONTEXT at ui/webview/helpHtml.ts:43 matches deckard.onTaskLine and deckard.isNote in palette when clauses to decide which commands Help may run. src/test/extension.test.ts:342 looks for the three onContext: keys in compiled text; see section 8.

Keys VS Code sets from settings

All five settings are declared. The walkthrough also completes on onSettingChanged:deckard.theme and onSettingChanged:deckard.zenMode, both declared.

Built-in keys

The remaining clauses use VS Code’s own keys: view (38 clauses), editorLangId (20), viewItem (14), workspaceFolderCount (9), resourcePath (8), explorerResourceIsFolder (6), resourceLangId (6), inQuickOpen (4), editorTextFocus (3), resourceExtname (3), and activeWebviewPanelId (2). Two of them depend on Deckard’s own names. view == compares against the view ids deckard.agenda (14 clauses), deckard.outline (11), deckard.calendar (7), and deckard.relatedNotes (6). activeWebviewPanelId =~ /^deckard\./ depends on every panel view type starting with deckard..

Tree item contextValues

viewItem clauses match the contextValue a tree item carries. A move that changes one of these strings hides the item’s menu entries.

Questions

• deckard.zenMode follows the setting only at activation and after Deckard writes it through setZenMode(). No configuration listener calls syncZenModeContext(), so an edit to deckard.zenMode in the Settings editor or settings.json leaves the palette’s Enable Zen Mode and Disable Zen Mode, and the zen buttons in editor/title, reading the old value until the next activation. deckard.outlineFollowCursor, the analogous key, does resync on deckard.outline changes at ui/views/outlineTree.ts:101.
• deckard.zenMode is both a setting and a context key of the same name. A rename of either must not assume the other follows.

5. Command re-entry

Source re-enters Deckard’s own commands through vscode.commands.executeCommand and through command fields that VS Code runs on a click. A rename of any id below, or a change to the WriteHistory design in §2.3 of the plan, must keep these callers working.

executeCommand with a deckard.* target

That is 39 distinct ids, not counting Help’s open set. Two of them, deckard.agenda.focus and deckard.relatedNotes.focus, are not registered by Deckard: VS Code generates them from the view ids. The other 37 are registered.

command fields and command links in source

VS Code runs these ids when a reader clicks a tree item, a CodeLens, a code action, a status bar item, or a trusted hover link.

6. Webviews and views

The two tables below and the paragraphs with them are as of the end of Phase 6 (030ee64), refreshed from the code when Phase 6 rewrote every page. The language model tools further down still describe 1805a01.

Editor panels

Seven panel view types have both a serializer and an onWebviewPanel: activation event, and they match one to one. An eighth view type, deckard.relatedNotesDebug, has neither, so that panel does not come back after a reload. Since Phase 6 every panel but the search page’s is made by one vscode.window.createWebviewPanel call, in PanelAdapter.open (src/ui/webview/host/panelAdapter.ts:65), with the view type its host names; the search page, which can hold several panels, still makes its own (src/ui/webview/searchPage.ts:408). The serializers are registered in registerSerializers, src/composition/services.ts:1088.

Two more readers depend on the view types’ deckard. prefix: hasVisibleDeckardPage() at ui/commands/chooseTheme.ts:56, which tests viewType.includes('deckard.'), and the two editor/title zen buttons, whose when tests activeWebviewPanelId =~ /^deckard\./.

Sidebar views

contributes.viewsContainers.activitybar declares the container deckard at package.json:1393. contributes.views.deckard declares four views. Each has one registration, in registerViews, src/composition/services.ts:1031. No source calls registerTreeDataProvider.

VS Code derives command ids from these names, and the source runs three of them: workbench.view.extension.deckard from the container id (ui/webview/pages/sidebarNotes/sidebarNotesController.ts:280, 292), deckard.agenda.focus (ui/views/taskStatusBar.ts:154, ui/webview/pages/dashboard/dashboardController.ts:471, package.json:141), and deckard.relatedNotes.focus (ui/commands/noteActions.ts:50). viewsWelcome names deckard.outline and deckard.agenda at package.json:203, 207, and 212.

Language model tools

The MCP server reads the same declarations at run time: src/extension.ts:407 passes contributes.languageModelTools to readManifestTools(). The two write tools have no activation event and no when. onStartupFinished activates the extension anyway, so the missing event matters only if that event is ever dropped. With deckard.assistantTools off, the write tools stay offered and refuse the call at ui/commands/assistantTools.ts:170.

7. Other bindings from package.json into the tree

Every path above exists in a checkout at 1805a01, except dist/extension.js, which the build writes.

Files the source reads from the extension folder at run time

These are not named in package.json, but they bind a source path to a shipped file, and .vscodeignore must keep shipping them.

The source also reads the manifest itself at run time: packageJSON.version at src/extension.ts:196, 222, 275, 409, and 463; packageJSON.contributes for Help at src/extension.ts:478 and for Choose Theme at src/extension.ts:928, which reads the enumDescriptions of deckard.theme (ui/commands/chooseTheme.ts:43).

8. Traps

These tests and scripts would fail, or would pass while checking nothing, after a move that changes no behavior.

The 35 modules are out/core/changelog.js, out/core/markdown/parser.js, out/core/storage/parsedFileCodec.js, out/core/storage/preferences.js, out/core/storage/searchStore.js, out/core/timing.js, out/core/workspace/indexer.js, out/core/workspace/scanner.js, out/ui/commands/dailyNote.js, out/ui/commands/tagDecorations.js, out/ui/state/calendarState.js, out/ui/state/dashboardState.js, out/ui/state/notesGraphState.js, out/ui/state/relatedNotesRanking.js, out/ui/state/taskBoardState.js, and, under out/ui/webview/, activeCalendar.js, activeSearch.js, calendar.js, calendarHtml.js, calendarPage.js, components.js, dashboard.js, dashboardHtml.js, helpHtml.js, notesGraphHtml.js, relatedNotesDebugHtml.js, searchPage.js, searchPageHtml.js, sidebarNotes.js, sidebarNotesHtml.js, stats.js, statsHtml.js, taskBoard.js, taskBoardHtml.js, and themes.js.

Several tests read package.json as JSON and pin the manifest itself. They guard behavior and do not break on a move: src/test/extension.test.ts:92 asserts 73 settings, src/test/extension.test.ts:117 asserts the ordered list of all 96 contributed ids, and src/test/naming.test.ts:115 and 138 check command titles. No test asserts that every contributed command is registered; src/test/extension.test.ts checks 11 ids through getCommands(true), starting at line 360.

Behavior questions

• No dead setting and no undeclared read. All 73 declared settings are read, and nothing else under deckard.* is.
• No context key without a setter. All 19 keys that Deckard’s when clauses and walkthrough events name are set.
• deckard.zenMode does not resync on a settings edit. The context key is set at activation (src/extension.ts:756) and after setZenMode() writes (ui/webview/zenMode.ts:79), and no configuration listener updates it. See section 4.
• deckard.relatedNotesDebug has no serializer. The debug panel does not survive a reload. It is a developer tool, so this is likely deliberate.
• The two write tools have no activation event or when. deckard_add_task and deckard_change_task rely on onStartupFinished. They stay offered to the model when deckard.assistantTools is off, unlike the two read tools, and the code then refuses the call (ui/commands/assistantTools.ts:170).

How to regenerate

Run each command from the repository root of a checkout at 1805a01 with node_modules installed. None of them writes a file.

Commands contributed and registered (section 1):

node - <<'EOF'
const fs = require('fs'), cp = require('child_process');
const files = cp.execSync("find src -type f -name '*.ts' -not -path 'src/test/*' | sort", { encoding: 'utf8' }).trim().split('\n');
const consts = {};
for (const f of files) for (const m of fs.readFileSync(f, 'utf8').matchAll(/export const (\w+_COMMAND) = '([^']+)'/g)) consts[m[1]] = m[2];
const registered = [];
for (const f of files) {
  const t = fs.readFileSync(f, 'utf8');
  for (const m of t.matchAll(/register(?:TextEditor)?Command\(\s*([^,)]+)/g)) {
    const arg = m[1].trim();
    registered.push([consts[arg] ?? arg.replace(/^'|'$/g, ''), `${f}:${t.slice(0, m.index).split('\n').length}`]);
  }
}
const contributed = JSON.parse(fs.readFileSync('package.json', 'utf8')).contributes.commands.map((c) => c.command);
const ids = new Set(registered.map(([id]) => id));
console.log('registered', registered.length, 'distinct', ids.size, 'contributed', contributed.length);
console.log('registered, not contributed', registered.filter(([id]) => !contributed.includes(id)));
console.log('contributed, not registered', contributed.filter((id) => !ids.has(id)));
EOF

Menu and keybinding references (section 2):

node - <<'EOF'
const fs = require('fs');
const c = JSON.parse(fs.readFileSync('package.json', 'utf8')).contributes;
const contributed = new Set(c.commands.map((x) => x.command));
const refs = [...Object.entries(c.menus).flatMap(([menu, items]) => items.filter((i) => i.command).map((i) => [menu, i.command])),
  ...c.keybindings.map((k) => ['keybindings', k.command])];
console.log('menu and keybinding references', refs.length);
console.log('not contributed', refs.filter(([, id]) => !contributed.has(id)));
const submenus = new Set(c.submenus.map((s) => s.id));
console.log('submenu refs', Object.values(c.menus).flat().filter((i) => i.submenu).map((i) => [i.submenu, submenus.has(i.submenu), i.submenu in c.menus]));
const links = [...fs.readFileSync('package.json', 'utf8').matchAll(/command:(deckard\.[\w.]+)/g)].map((m) => m[1]);
console.log('command: links', links.length, 'distinct', new Set(links).size, 'not contributed', [...new Set(links)].filter((id) => !contributed.has(id)));
EOF
grep -n 'command:deckard\.' package.json

Settings (section 3). This uses the TypeScript checker, so a key held in a constant or a literal union resolves to its values. It prints the rows it could not resolve; section 3 resolves them by hand. Set ROWS=/some/file.tsv to also write every call as a row.

node - <<'EOF'
const ts = require('typescript'), path = require('path'), fs = require('fs');
const root = process.cwd();
const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile('tsconfig.json', ts.sys.readFile).config, ts.sys, root);
const program = ts.createProgram(parsed.fileNames, parsed.options);
const checker = program.getTypeChecker();
const literals = (node) => {
  const type = checker.getTypeAtLocation(node);
  return (type.isUnion() ? type.types : [type]).map((t) => (t.isStringLiteral() ? t.value : `<${checker.typeToString(t)}>`));
};
const section = (e) => {
  if (ts.isCallExpression(e) && ts.isPropertyAccessExpression(e.expression) &&
      e.expression.name.text === 'getConfiguration' && e.expression.expression.getText() === 'vscode.workspace')
    return literals(e.arguments[0]).join('|');
  const d = ts.isIdentifier(e) ? checker.getSymbolAtLocation(e)?.valueDeclaration : undefined;
  if (d && (ts.isVariableDeclaration(d) || ts.isParameter(d)) && d.initializer) return section(d.initializer);
  return '?';
};
const rows = [];
for (const sf of program.getSourceFiles()) {
  const rel = path.relative(root, sf.fileName);
  if (!rel.startsWith('src/') || rel.startsWith('src/test/')) continue;
  const visit = (n) => {
    if (ts.isCallExpression(n) && ts.isPropertyAccessExpression(n.expression) && n.arguments[0]) {
      const name = n.expression.name.text;
      const at = `${rel}:${sf.getLineAndCharacterOfPosition(n.expression.name.getStart()).line + 1}`;
      if (['get', 'inspect', 'update', 'has'].includes(name) &&
          /WorkspaceConfiguration/.test(checker.typeToString(checker.getTypeAtLocation(n.expression.expression))))
        rows.push([at, name, section(n.expression.expression), literals(n.arguments[0]).join('|')]);
      if (name === 'affectsConfiguration') rows.push([at, 'affects', '', literals(n.arguments[0]).join('|')]);
    }
    ts.forEachChild(n, visit);
  };
  visit(sf);
}
if (process.env.ROWS) fs.writeFileSync(process.env.ROWS, rows.map((r) => r.join('\t')).join('\n') + '\n');
const declared = JSON.parse(fs.readFileSync('package.json', 'utf8')).contributes.configuration.flatMap((g) => Object.keys(g.properties));
const reads = rows.filter((r) => r[1] !== 'affects');
const read = new Set(reads.filter((r) => r[2] === '?' || /^deckard/.test(r[2]))
  .flatMap((r) => r[3].split('|').filter((k) => !k.startsWith('<')).map((k) => `${r[2] === '?' ? 'deckard' : r[2]}.${k}`)));
console.log('calls', rows.length, '| get/inspect/update/has', reads.length, '| affectsConfiguration', rows.length - reads.length);
console.log('declared', declared.length, '| distinct deckard keys read by a literal or literal-union key', read.size);
console.log('read, not declared', [...read].filter((k) => !declared.includes(k)));
console.log('declared, no literal read (resolve by hand)', declared.filter((k) => !read.has(k)));
console.log('non-literal keys (resolve by hand)', reads.filter((r) => r[3].includes('<')).map((r) => r[0]));
console.log('section not literal, taken as deckard (check by hand)', reads.filter((r) => r[2] === '?').map((r) => r[0]));
console.log('other sections', reads.filter((r) => r[2] !== '?' && !/^deckard/.test(r[2])).map((r) => `${r[0]} ${r[2]}.${r[3]}`));
console.log('affectsConfiguration keys that are not declared settings', [...new Set(rows.filter((r) => r[1] === 'affects').map((r) => r[3]))].filter((k) => !declared.includes(k)));
EOF

At 1805a01 it prints 221 calls, 68 keys read by a literal key, and five declared keys to resolve by hand (the three period templates and the two editor.* keys that editorReferences.ts builds), which gives 73. The helper callers credited in the Writes column come from:

grep -rnE "(writeSetting|settingTarget|settingPlace|zenModeTarget)\(" src --exclude-dir=test
grep -rnA1 -E "writeSetting\($" src --exclude-dir=test
grep -rn "readTaskMetadataFormat(" src --exclude-dir=test

when clauses and context keys (section 4). The first script counts clauses and the keys they use. The second lists every setter.

node - <<'EOF'
const fs = require('fs');
const contributes = JSON.parse(fs.readFileSync('package.json', 'utf8')).contributes;
const clauses = [], events = [];
const walk = (o, at) => {
  if (Array.isArray(o)) o.forEach((x) => walk(x, at));
  else if (o && typeof o === 'object')
    for (const [k, v] of Object.entries(o)) {
      if ((k === 'when' || k === 'enablement') && typeof v === 'string') clauses.push([at, v]);
      else if (k === 'completionEvents') events.push(...v);
      else walk(v, at ? `${at}.${k}` : k);
    }
};
walk(contributes, '');
console.log('when/enablement clauses', clauses.length, '| literally false', clauses.filter(([, v]) => v === 'false').length);
const keys = {};
for (const [at, v] of clauses) {
  // Drop right-hand values of ==, !=, =~ so a view id or a viewItem is not taken for a key.
  const bare = v.replace(/(==|!=)\s*[^\s&|)]+|=~\s*\/(?:\\.|[^/])*\/\w*|'[^']*'/g, ' ');
  for (const key of new Set(bare.match(/[A-Za-z_][\w.-]*/g) ?? []))
    if (!['in', 'not', 'true', 'false'].includes(key)) (keys[key] ??= []).push(at);
}
for (const e of events) { const k = /^onContext:(.+)$/.exec(e)?.[1]; if (k) (keys[k] ??= []).push('walkthroughs.completionEvents'); }
for (const [k, uses] of Object.entries(keys).sort()) console.log(k, uses.length);
EOF
node - <<'EOF'
const fs = require('fs'), cp = require('child_process');
const files = cp.execSync("find src -type f -name '*.ts' -not -path 'src/test/*' | sort", { encoding: 'utf8' }).trim().split('\n');
const text = Object.fromEntries(files.map((f) => [f, fs.readFileSync(f, 'utf8')]));
const consts = {};
for (const t of Object.values(text)) for (const m of t.matchAll(/const (\w+) = '(deckard\.[\w.]+)'/g)) consts[m[1]] = m[2];
const line = (t, i) => t.slice(0, i).split('\n').length;
const setters = [];
for (const [f, t] of Object.entries(text)) {
  for (const m of t.matchAll(/(?:executeCommand|execute)\(\s*'setContext',\s*([^,\s]+)/g))
    setters.push([m[1].startsWith("'") ? m[1].slice(1, -1) : consts[m[1]] ?? `<${m[1]}>`, `${f}:${line(t, m.index)}`, m[1].startsWith("'") ? 'literal' : 'indirect']);
  for (const m of t.matchAll(/this\.update\('(deckard\.[\w.]+)'/g)) setters.push([m[1], `${f}:${line(t, m.index)}`, 'ActiveNoteContext']);
}
for (const s of setters.sort()) console.log(s.join('\t'));
const keys = new Set(setters.map(([k]) => k).filter((k) => k.startsWith('deckard.')));
console.log('distinct keys set', keys.size, '| literal', new Set(setters.filter((s) => s[2] === 'literal').map(([k]) => k)).size);
EOF
grep -rhoE "'setContext', 'deckard\.[A-Za-z.]+'" src --exclude-dir=test | sort -u
grep -rn "contextValue" src --exclude-dir=test

Command re-entry (section 5). The first line gives the plan’s single-line count of 18; the script gives 21 with calls that span lines, then lists every executeCommand with its first argument so the constants, templates, maps, and runners can be resolved by hand.

grep -rhoE "executeCommand\('deckard\.[A-Za-z.]+'" src --exclude-dir=test | sort -u | wc -l
node - <<'EOF'
const fs = require('fs'), cp = require('child_process');
const files = cp.execSync("find src -type f -name '*.ts' -not -path 'src/test/*' | sort", { encoding: 'utf8' }).trim().split('\n');
const literal = new Set();
for (const f of files) {
  const t = fs.readFileSync(f, 'utf8');
  for (const m of t.matchAll(/executeCommand\(\s*'(deckard\.[\w.]+)'/g)) literal.add(m[1]);
  for (const m of t.matchAll(/executeCommand\(\s*([^,)]+)/g))
    if (!m[1].startsWith("'setContext'")) console.log(`${f}:${t.slice(0, m.index).split('\n').length}\t${m[1].trim().replace(/\s+/g, ' ')}`);
}
console.log('distinct literal deckard ids', literal.size);
EOF
grep -rnE "command: *['\"]deckard\.|command: *[A-Z_]+_COMMAND|\.command = [A-Z_]+|enabledCommands|command:deckard\.|createTagCommandUri\('deckard" src --exclude-dir=test
grep -n "run('deckard" src/ui/commands/tryNext.ts

Webviews and views (section 6):

grep -rnE "registerWebviewPanelSerializer|createWebviewPanel|registerTreeDataProvider|createTreeView|registerWebviewViewProvider" src --exclude-dir=test
node -e "const c=require('./package.json');console.log(c.activationEvents);console.log(JSON.stringify(c.contributes.views));console.log(c.contributes.languageModelTools.map(t=>[t.name,t.when]))"

File bindings (section 7):

node -e "const fs=require('fs');const t=fs.readFileSync('package.json','utf8');const walk=(o,p)=>{if(Array.isArray(o))o.forEach((x,i)=>walk(x,p+'['+i+']'));else if(o&&typeof o==='object')for(const[k,v]of Object.entries(o))walk(v,p+'.'+k);else if(typeof o==='string'&&/^\.?\/?(src|dist|resources|syntaxes|docs)\//.test(o))console.log(p,o,fs.existsSync(o.replace(/^\.\//,''))?'exists':'MISSING')};walk(JSON.parse(t),'')"
grep -rnE "joinPath\((this\.)?(context\.)?extensionUri|__dirname|packageJSON" src --exclude-dir=test

Traps (section 8):

grep -rnE "readFileSync|readdirSync|statSync|__dirname" src/test | grep -v "src/test/fixtures/"
grep -rhoE "\.\./\.\./out/[A-Za-z/]+\.js" test | sort -u
grep -oE "load\('[^']+'\)" test/perf/indexSpeed.js | sort -u