type-atlas

Type Atlas ist das, was ich all meinen Code-Agenten in all meinen TypeScript-Projekten für sämtliche Code-Navigationsanforderungen verwenden lasse. Die meisten dieser Projekte sind Monorepos. Einige sind groß und komplex genug, dass das Verständnis, wie eine Änderung in den Rest des Systems passt, ein echter Teil der Arbeit ist. Dieses Tool wurde als vollständiger Ersatz für die standardmäßige Code-Navigationsmethodik eines Agenten entwickelt.

Ich habe monatelang an diesem Tool iteriert, basierend darauf, wie meine eigenen Coding-Agenten tatsächlich in meinen Projekten arbeiten. Das meiste, was Type Atlas tut, existiert, weil ich immer wieder dieselben Probleme gesehen habe:

• Agenten schlussfolgern aus einer unvollständigen Sicht des Systems. Sie verstehen vielleicht die Datei, die sie gefunden haben, übersehen aber den umgebenden Code, der bestimmt, wie sie verwendet werden soll.

• Agenten bauen Dinge neu, die bereits existieren. Die Fähigkeit ist bereits im Repo vorhanden, aber der Agent findet sie nie, weil er nicht weiß, wie sie heißt.

• Agenten lesen oft entweder zu wenig Code (Claude) oder viel zu viel (Codex). Zu wenig lässt sie Entscheidungen ohne ausreichenden umgebenden Kontext treffen. Zu viel füllt den Kontextfenster mit ganzen Dateien und Implementierungsdetails, die für die Aufgabe nie relevant waren.

• Agenten stoppen wiederholt, um Typprüfungen auszuführen, nur um Fehler zu finden, die eine IDE bereits anzeigen würde. Das fügt während der Implementierung Latenz hinzu und verschiebt Feedback später, als es ankommen müsste.

• Agenten arbeiten grundsätzlich blind. String-Such-Navigation gibt ihnen nie einen starken internen Atlas der Codebasis. Sie sind gezwungen, Implementierungsentscheidungen aus Fragmenten von Dateien und Treffern zu treffen, die sie zufällig abgerufen haben, während wichtige Struktur- und compilerbekannte Informationen fehlen.

Wenn Projekte wachsen, verstärken sich diese Probleme und zeigen sich direkt in der Qualität des Codes, den Agenten schreiben.

Semantische Code-Navigation

Coding-Agenten navigieren standardmäßig durch Dateilesen und String-Suchen. Das gibt ihnen Quelltext und überlässt es dem Modell, Beziehungen zu rekonstruieren, die der TypeScript-Sprachdienst bereits kennt.

Type Atlas gibt dem Agenten direkten Zugriff auf diese semantischen Informationen:

• Ein Symbol löst sich zu seiner tatsächlichen Definition und seinen Referenzen auf, statt zu jedem Vorkommen desselben Texts.

• Aufrufer und Implementierungen werden durch ihre Beziehung zum Symbol identifiziert.

• Abgeleitete Typen kommen vom Sprachdienst, statt aus nahegelegenem Quellcode rekonstruiert zu werden.

• Ergebnisse behalten ihren Quellbereich und ihr zugehöriges TypeScript-Projekt bei.

Ein Texttreffer ist weiterhin nützlich, wenn Text das ist, wonach der Agent sucht. Er ist ein schwacher Ersatz für semantische Navigation, wenn es um das Programm selbst geht.

Finden, was bereits existiert

Große Codebasen enthalten nützlichen Code, dessen Namen ein Agent keinen Grund hat zu kennen. String-Suche funktioniert am besten, nachdem der Agent bereits genug Vokabular kennt, um die Suche zu formulieren.

Type Atlas gibt ihm andere Wege hinein:

• Der Agent kann Verhalten in natürlicher Sprache beschreiben und Code basierend darauf finden, was er tut.

• Ein gefundenes Ergebnis führt zurück zu einem echten Symbol und einem exakten Quellbereich.

• Von diesem Symbol aus kann der Agent tatsächlichen Beziehungen durch die Codebasis folgen, statt eine weitere Kennung zum Suchen zu erraten.

Das ist besonders nützlich in großen Monorepos. Vorhandene Helfer und etablierte Implementierungen sind leichter zu entdecken, bevor der Agent entscheidet, dass er eine weitere erstellen muss.

Diagnostik während der normalen Arbeit

Ein Entwickler in einer IDE sieht Compiler-Feedback während der Arbeit. Coding-Agenten erhalten dieses Feedback normalerweise, indem sie die Implementierung stoppen, um einen Typprüfungsbefehl auszuführen, und dann auf das Ergebnis warten.

Type Atlas verlagert viel von diesem Feedback in Arbeit, die der Agent ohnehin schon erledigt:

• Relevante Diagnostik kann mit normalen Code-Intelligenz-Antworten eintreffen.

• Fehler erscheinen, während der betroffene Code noch Teil des aktuellen Arbeitskontexts des Agenten ist.

• Eine falsche Typannahme kann erkannt werden, bevor sie sich in mehrere abhängige Bearbeitungen verwandelt.

Ich verwende weiterhin vollständige Typprüfungen zur Verifikation. Sie müssen nicht der Hauptweg sein, auf dem ein Agent während der Arbeit von Fehlern erfährt.

Antworten sind für den Modellkontext gebaut

Eine Antwort kleiner zu machen, ist nur nützlich, wenn die entfernte Information unnötig war. Modelle nutzen auch die Organisation dessen, was übrig bleibt.

Type Atlas behandelt Struktur als Teil der Information:

• Beschriftungen machen die Rolle eines Ergebnisses explizit.

• Gruppierung hält zusammengehörige Fakten zusammen.

• Dateigrenzen verhindern, dass unzusammenhängender Quellcode verschmilzt.

• Quellpositionen bleiben an dem haften, was sie beschreiben.

• Bäume behalten ihre Hierarchie, statt zu einer flachen Sequenz zu werden.

• Diagnostik behält den Quellcode, der zum Verstehen nötig ist.

Dasselbe Prinzip bestimmt, was weggelassen wird. Funktionskörper können eingeklappt bleiben, wenn die Signatur ausreicht. Wiederholte Serialisierung und unzusammenhängender Quellcode müssen das Kontextfenster nicht belegen, nur weil sie verfügbar waren.

Das Ziel ist nützliche Informationsdichte. Weniger Tokens zählen, aber die Struktur zu entfernen, die dem Modell hilft, diese Tokens zu verstehen, würde den Zweck verfehlen.

Informationen für die nächste Entscheidung

Jeder Tool-Aufruf ist Teil des Denkprozesses des Agenten. Eine gute Antwort sollte die aktuelle Frage beantworten und den Agenten gleichzeitig in eine bessere Position versetzen, um zu entscheiden, was als Nächstes zu untersuchen ist.

Type Atlas hält nützliche Folgeinformationen nahe am Ergebnis, das sie offengelegt hat:

• Ein Symbol kann mit den Beziehungen eintreffen, die nötig sind, um zu verstehen, wie es an der Codebasis teilnimmt.

• Die Repository-Struktur kann Zeilenzahlen und Arbeitsbaum-Zustand zusammen mit den Dateien selbst tragen.

• Suchergebnisse enthalten konkrete Quellbereiche, denen direkt gefolgt werden kann.

• Der Projektkontext bleibt angehängt, während sich der Agent von einem Ergebnis zum nächsten bewegt.

Das gibt dem Agenten bessere Belege an jeder Verzweigung seiner Untersuchung. Er kann Beziehungen folgen, die tatsächlich im Programm existieren, statt jeden Texttreffer als gleich bedeutsame Spur zu behandeln.

Der Nutzen ist Navigation von höherer Qualität. Jeder Schritt bewahrt mehr von der Information, die nötig ist, um den nächsten zu wählen.

Projekt- und Bereichsbewusstsein

TypeScript-Fragen hängen vom Projektkontext ab. Das wird besonders wichtig in einem Monorepo, wo eine Antwort innerhalb eines Projekts korrekt sein kann, während sie für das Repository als Ganzes dennoch unvollständig ist.

Type Atlas hält diese Grenzen sichtbar:

• Dateien werden über das TypeScript-Projekt aufgelöst, dem sie gehören.

• Ergebnisse geben den Projektbereich an, aus dem sie stammen, wenn dieser Bereich von Bedeutung ist.

• Zählungen machen die Größe eines Ergebnisses explizit.

• Grenzen werden angegeben, wenn eine Antwort weniger als das gesamte Repository abdeckt.

• Quellpositionen können direkt in spätere Aufrufe übergeben werden.

Der Agent erhält genug Informationen, um zu verstehen, was eine Antwort tatsächlich abdeckt, bevor er sich darauf verlässt.

Aus täglicher Agentennutzung entstanden

Ich verwende Type Atlas jeden Tag mit meinen eigenen Coding-Agenten in all meinen TypeScript-Projekten. Das aktuelle Verhalten entstand aus wiederholter Nutzung.

Ein Großteil des Designs lässt sich direkt auf wiederkehrendes Agentenverhalten zurückführen:

• Lesevorgänge werden eingeklappt, weil Agenten Kontext für Körper ausgaben, die sie nicht brauchten.

• Diagnostik reist mit normalen Antworten, weil wiederholte Typprüfungsbefehle Implementierungszeit verschwendeten.

• Semantische Beziehungen werden gruppiert, weil Agenten immer wieder dieselben Informationen durch separate Aufrufe rekonstruierten.

• Natürlichsprachliche Codesuche existiert, weil nützlicher Code oft einen Namen hat, den der Agent nie aus der Aufgabe ableiten konnte.

So arbeite ich weiterhin an Type Atlas. Wenn ich immer wieder sehe, dass Agenten Zeit mit demselben Navigationsproblem verschwenden oder wiederholt dieselbe Art von Information übersehen, ändere ich das Tool.

Die Beispiele unten sind vom laufenden Server gegen ein Fixture-Monorepo erfasst und mit der Implementierung regressionsgeprüft.

Installation

codex mcp add type-atlas -- npx --yes @type-atlas/mcp@latest

claude mcp add --scope user type-atlas -- npx --yes @type-atlas/mcp@latest

code --add-mcp '{"name":"type-atlas","command":"npx","args":["--yes","@type-atlas/mcp@latest"]}'

Jeder andere Client nimmt die Standardform an:

{
  "mcpServers": {
    "type-atlas": {
      "command": "npx",
      "args": ["--yes", "@type-atlas/mcp@latest"]
    }
  }
}

Ein Client, der Server ohne Ihre Shell-PATH startet, findet npx nicht beim Namen; geben Sie in diesem Fall den absoluten Pfad von which npx an. Unter Windows benötigt ein Client, der den npx.cmd-Shim nicht starten kann, "command": "cmd" mit "args": ["/c", "npx", "--yes", "@type-atlas/mcp@latest"].

Clients lesen die MCP-Konfiguration beim Start, also danach neu starten. @latest wird bei jedem Prozessstart aufgelöst; pinnen Sie eine Version, wenn Sie nicht möchten, dass sich das Tool-Verhalten unter Ihnen wegbewegt.

search_code, related_code, investigate_code und search_dependency_code führen einen semantischen Index über uvx aus und benötigen uv. Ohne es melden diese vier, dass uv fehlt, explore_symbol lässt seinen Related-Code-Abschnitt weg, und der Rest ist nicht betroffen.

Empfohlen

Die Installation des Servers ändert nicht, wonach ein Agent greift. Einige Agenten, darunter Claude, setzen zusammen, was ihre Shell erlaubt, verketten es und produzieren jedes Mal eine neue Rechtfertigung, also hilft es nicht, ein paar Befehle zu nennen, die vermieden werden sollen. Die Anweisung muss die gesamte Kategorie ausschließen und die Ausnahmen benennen. Fügen Sie dies zu AGENTS.md oder CLAUDE.md hinzu:

Type Atlas MCP ist das erforderliche Werkzeug zum Lesen und Navigieren von Code in TypeScript und JavaScript. Das ist keine Präferenz. Kein Shell-Befehl ist ein akzeptabler Ersatz, egal woraus er zusammengesetzt ist, und auch kein einfaches Dateilesen. Die einzigen gültigen Ausweichmöglichkeiten sind ein Server, der nicht erreichbar ist, ein Aufruf, der einen Fehler ergeben hat, oder eine Datei, die weder TS noch JS ist.

--require-intent

Dieses Opt-in-Flag erfordert einen Entscheidungssatz für breite Erkundungswerkzeuge wie Repository-Suche und Workspace-Symbole. Gezielte Lesevorgänge und semantische Nachschlagevorgänge bleiben unberührt, und Absicht wird nie in Tool-Antworten zurückgespiegelt.

Related MCP server: agent-workspace-mcp

Tool-Aufrufergebnisse

Pfade sind workspace-relativ, Koordinaten sind einsbasiert, also ist eine Position in einer Antwort gültige Eingabe für den nächsten Aufruf. Bearbeitungswerkzeuge geben Patches zurück; nichts wird für Sie geschrieben.

Alles unten ist vom laufenden Server gegen fixtures/ledger von der Szenario-Suite erfasst, die dieselben Aufrufe wiedergibt und bei Abweichung fehlschlägt. Nichts hier ist handgeschrieben, und das Ändern dessen, was ein Tool beantwortet, ändert diese Datei im selben Commit. Die Quelle ist README.mdoc. Jedes Tool hat eine Seite mit weiteren Fällen in docs/tools.

list_files

Struktur, Zeilenzahlen und git status in einem Baum, mit den Badge-Buchstaben, die Editoren bereits verwenden. Gelöschte Dateien erhalten eine Zeile, obwohl sie nur in gits Antwort existieren. Eingeklappte Verzeichnisse sagen, was sie enthalten, statt zu verschwinden.

Eingabe des Agenten

tool: List files
workspace: fixtures/ledger
# working tree arranged: currency.ts edited · rounding.ts created · index.ts deleted
directory: packages/money
depth: 2

# answered in 57ms

Antwort

packages/money/
├  src/ · 3 changed
│  ├  currency.ts · 21 loc · M +2
│  ├  index.ts · D -12
│  ├  money.ts · 58 loc
│  ├  rounding-mode.ts · 15 loc
│  └  rounding.ts · 11 loc · U
├  tests/
│  ├  money.test.ts · 15 loc
│  └  rounding-parity.ts · 15 loc
├  package.json · 19 loc
└  tsconfig.json · 20 loc

inspect_symbol

Hover, Definitionen, Typdefinitionen, Implementierungen, Aufrufer, Aufrufe und Referenzen in einem Aufruf. Referenzen sind der Rest, nachdem Aufrufer und Definitionen berücksichtigt sind, also wird eine Verwendung einmal aufgelistet. Gegenüber dem separaten Aufrufen dieser Werkzeuge sind es 4x weniger Zeichen und 7x weniger Roundtrips.

Eingabe des Agenten

tool: Inspect symbol
workspace: fixtures/ledger
file: packages/accounts/src/journal.ts
symbol: Journal

# answered in 49ms

Antwort

Journal [class] · packages/accounts/src/journal.ts:24:14-24:21 · range 24:1-73:2 · packages/accounts/tsconfig.json

```typescript
class Journal<TMeta = undefined>
```

An append-only journal of balanced entries. `TMeta` carries whatever a
consumer attaches to each entry — an import batch id, an approval trail —
without the journal knowing its shape.

## Callers (4)

packages/accounts/tests/journal.test.ts
├  test("posts a balanced transfer through the overload") callback [function] 5:56-14:2 · calls 6:23-6:30
└  test("refuses an unbalanced entry") callback [function] 16:37-29:2 · calls 17:23-17:30
packages/reports/src/balance.ts
└  balancesAsOf [variable] 23:14-23:26 · range 23:14-51:2 · calls 24:12-24:19
packages/importers/src/csv.ts
└  importStatement [variable] 28:14-28:29 · range 28:14-47:2 · calls 29:12-29:19

## Mentions that are not calls (4 of 9 references · 5 relevant projects searched)

packages/accounts/tests/journal.test.ts:3:25-3:32:  import { credit, debit, Journal, UnbalancedEntryError } from "../src/index.ts";
packages/accounts/src/index.ts:11:22-11:29:  export { type Entry, Journal, UnbalancedEntryError } from "./journal.ts";
packages/reports/src/balance.ts:4:8-4:15:  type Journal,
packages/importers/src/csv.ts:1:10-1:17:  import { Journal, type Entry, credit, debit, type AccountPath } from "@ledger/accounts";

references lists all 9, with paging.

read_file

Das Argument ist ein Array, sodass mehrere Dateien in einem Aufruf eintreffen. Körper klappen standardmäßig zu Signaturen ein, und der Kopf sagt, wie viele Zeilen das gespart hat; fold: false gibt sie zurück.

Eingabe des Agenten

tool: Read files
workspace: fixtures/ledger
file: ["packages/accounts/src/posting.ts","packages/money/src/rounding-mode.ts"]

# answered in 7ms

Antwort

2 files · 42 lines · 6 folded to signatures, pass fold: false for the bodies

=== packages/accounts/src/posting.ts · 32 lines ===

 1 | import { type Money, negate } from "@ledger/money";
 2 | import type { AccountPath } from "./account.ts";
 3 |
 4 | /**
 5 |  * One side of a journal entry. The discriminant is the bookkeeping side, so
 6 |  * every consumer's switch is checked for exhaustiveness by the compiler.
 7 |  */
 8 | export type Posting =
 9 |   | { readonly side: "debit"; readonly account: AccountPath; readonly amount: Money }
10 |   | { readonly side: "credit"; readonly account: AccountPath; readonly amount: Money };
11 |
12 | export const debit = (account: AccountPath, amount: Money): Posting => ({
13 |   side: "debit",
14 |   account,
15 |   amount,
16 | });
17 |
18 | export const credit = (account: AccountPath, amount: Money): Posting => ({
19 |   side: "credit",
20 |   account,
21 |   amount,
22 | });
23 |
24 | /** A posting's effect on a debit-normal running balance. */
25 | export const signedAmount = (posting: Posting): Money => {
   |   ... 26-31 folded
32 | };

=== packages/money/src/rounding-mode.ts · 15 lines ===

 1 | /** How sub-minor precision resolves when a statement and the books disagree. */
 2 | export enum RoundingMode {
 3 |   HalfUp = "half-up",
 4 |   HalfEven = "half-even",
 5 |   Truncate = "truncate",
 6 | }
 7 |
 8 | /** Per-institution conventions, as observed in their exports. */
 9 | const bankRounding: Readonly<Record<string, RoundingMode>> = {
10 |   "first-national": RoundingMode.HalfEven,
11 |   "harbor-credit": RoundingMode.HalfUp,
12 | };
13 |
14 | export const roundingModeOf = (bank: string): RoundingMode =>
15 |   bankRounding[bank] ?? RoundingMode.HalfEven;

occurrences

Wörtlicher Text, gruppiert nach Datei, mit der Anzahl der gescannten Dateien. Die semantischen Werkzeuge bewerten, was existiert, was nutzlos ist, um zu bestätigen, dass ein Token nach einem Teardown verschwunden ist; eine Null hier kommt mit derselben Scan-Anzahl, also bedeutet sie etwas.

Eingabe des Agents

tool: Occurrences
workspace: fixtures/ledger
text: signedAmount

# answered in 12ms

Antwort

"signedAmount" occurs 12 times in 7 files · 67 files scanned under the workspace · 1 file of declared build output not scanned.

packages/accounts/src/index.ts:12:39 · export { credit, debit, type Posting, signedAmount } from "./posting.ts";
packages/accounts/src/journal.ts
├  3:39  · import { credit, debit, type Posting, signedAmount } from "./posting.ts";
└  52:12 · .map(signedAmount)
packages/accounts/src/posting.ts:25:14 · export const signedAmount = (posting: Posting): Money => {
packages/reconcile/src/drift.ts
├  4:24  · import { type Posting, signedAmount } from "@ledger/accounts";
└  20:37 · const journalTotal = postings.map(signedAmount).reduce((total, amount) => total + amount);
packages/reconcile/src/matching.ts
├  1:55  · // DELIBERATELY BROKEN — the imports for `money` and `signedAmount` are
└  14:20 · const amount = signedAmount(posting);
packages/reports/src/balance.ts
├  6:3   · signedAmount,
└  34:57 · add(own.get(posting.account) ?? zero(currency), signedAmount(posting)),
packages/rules/src/builtin.ts
├  1:10  · import { signedAmount } from "@ledger/accounts";
└  26:12 · .map(signedAmount)

search_code

Findet Code danach, was er tut, für den Fall, dass man nicht erraten kann, wie er heißt. Treffer kommen in Rangfolge zurück, jeder mit dem Dateibereich, aus dem er stammt, sodass der nächste Aufruf ein Ziel hat. Live-Antworten enthalten außerdem einen Relevanzprozentsatz pro Treffer; dieser wird unten weggelassen, weil die zugrunde liegenden Embedding-Scores zwischen Maschinen variieren und diese Fälle Byte für Byte verglichen werden.

Eingabe des Agents

tool: Search code
workspace: fixtures/ledger
query: walking an account up through each of its ancestor accounts
snippetLines: 6

# answered in 20ms

Antwort

Search: walking an account up through each of its ancestor accounts

5 matches · no identifier to anchor on, so these are ranked by meaning alone

=== 1 · packages/accounts/src/account.ts:21-35 ===

Structure: parentPath
Symbol: parentPath [variable] · selection 21:14-21:24 · range 21:14-24:2

21 | export const parentPath = (path: AccountPath): AccountPath | undefined => {
22 |   const at = path.lastIndexOf(":");
23 |   return at === -1 ? undefined : path.slice(0, at);
24 | };
25 |
26 | /** Every ancestor from root to the account itself: `a`, `a:b`, `a:b:c`. */

=== 2 · packages/reports/src/balance.ts:1-23 ===

Structure: BalanceLine
Symbol: BalanceLine [interface] · selection 11:18-11:29 · range 11:1-16:2

1 | import {
2 |   type AccountPath,
3 |   type Entry,
4 |   type Journal,
5 |   lineage,
6 |   signedAmount,

=== 3 · packages/accounts/src/journal.ts:59-73 ===

Structure: Journal > history
Symbol: history [method] · selection 60:3-60:10 · range 60:3-64:4

59 |   /** Entries touching an account, oldest first. */
60 |   history(account: AccountPath): readonly Entry<TMeta>[] {
61 |     return this.entries.filter((entry) =>
62 |       entry.postings.some((posting) => posting.account === account),
63 |     );
64 |   }

=== 4 · packages/reports/src/statement.ts:1-11 ===

Structure: statementLine
Symbol: statementLine [variable] · selection 8:14-8:27 · range 8:14-11:2

1 | import { type Account, normalBalance } from "@ledger/accounts";
2 | import { format, type Money, negate } from "@ledger/money";
3 |
4 | /**
5 |  * One rendered statement line. The sign follows the account's normal side:
6 |  * a liability holding a credit balance reads as positive on its statement.

=== 5 · packages/accounts/src/posting.ts:1-24 ===

Structure: credit
Symbol: credit [variable] · selection 18:14-18:20 · range 18:14-22:3

1 | import { type Money, negate } from "@ledger/money";
2 | import type { AccountPath } from "./account.ts";
3 |
4 | /**
5 |  * One side of a journal entry. The discriminant is the bookkeeping side, so
6 |  * every consumer's switch is checked for exhaustiveness by the compiler.

diagnostics

Die eigene programmweite Prüfung des Compilers, pro Projekt, kein Durchlauf pro Datei. Eine Änderung in einer Datei bricht normalerweise eine andere, und dieser Aufruf findet diese Datei.

Eingabe des Agents

tool: Diagnostics
workspace: fixtures/ledger
file: packages/reconcile/src/drift.ts

# answered in 23ms

Antwort

packages/reconcile/src/drift.ts · 4 problems · packages/reconcile/tsconfig.json

=== packages/reconcile/src/drift.ts ===

error ts(2365) 16:33-16:52 — inside lines.reduce() callback
  Operator '+' cannot be applied to types 'number' and 'Money'.
   14 | /** Statement total, computed by someone who forgot Money is not a number.…
   15 | export const statementTotal = (lines: readonly StatementLine[]): number =>
   16 |   lines.reduce((total, line) => total + line.amount, 0);
      |                                 ^^^^^^^^^^^^^^^^^^^
   17 |
   18 | /** Drift between the journal's view and the bank's view of one day. */

error ts(2365) 20:77-20:91 — inside reduce() callback
  Operator '+' cannot be applied to types 'import("packages/money/src/money").Money' and 'import("packages/money/src/money").Money'.
   18 | /** Drift between the journal's view and the bank's view of one day. */
   19 | export const drift = (postings: readonly Posting[], statement: readonly St…
   20 |   const journalTotal = postings.map(signedAmount).reduce((total, amount) =…
      |                                                                             ^^^^^^^^^^^^^^
   21 |   return format(money(journalTotal - statementTotal(statement), "usd"));
   22 | };

error ts(2345) 21:65-21:70 — inside drift
  Argument of type '"usd"' is not assignable to parameter of type 'Currency'.
   19 | export const drift = (postings: readonly Posting[], statement: readonly St…
   20 |   const journalTotal = postings.map(signedAmount).reduce((total, amount) =…
   21 |   return format(money(journalTotal - statementTotal(statement), "usd"));
      |                                                                 ^^^^^
   22 | };
   23 |

error ts(2362) 21:23-21:35 — inside drift
  The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type.
   19 | export const drift = (postings: readonly Posting[], statement: readonly St…
   20 |   const journalTotal = postings.map(signedAmount).reduce((total, amount) =…
   21 |   return format(money(journalTotal - statementTotal(statement), "usd"));
      |                       ^^^^^^^^^^^^
   22 | };
   23 |

workspace_symbols

Findet eine Deklaration anhand des Namens in allen Projekten, die die Sitzung geladen hat, wenn man ungefähr weiß, wie sie heißt, aber nichts darüber, wo sie sich befindet.

Eingabe des Agents

tool: Workspace symbols
workspace: fixtures/ledger
file: packages/importers/src/statement-parser.ts
query: Parser

# answered in 100ms

Antwort

3 symbols matching Parser · 8 projects loaded · packages/importers/tsconfig.json

CsvStatementParser [class] · packages/importers/src/statement-parser.ts:25:1-35:2
FixedWidthStatementParser [class] · packages/importers/src/statement-parser.ts:41:1-64:2
StatementParser [class] · packages/importers/src/statement-parser.ts:7:1-23:2

file_references

Wer importiert dieses Modul. Die Frage auf Modulebene, beantwortet, ohne vorher ein Symbol darin auszuwählen.

Eingabe des Agents

tool: File references
workspace: fixtures/ledger
file: packages/money/src/money.ts

# answered in 134ms

Antwort

packages/money/src/money.ts · referenced from 90 places · 6 relevant projects searched · packages/money/tsconfig.json

1-20 of 90 places · pass offset: 20 for the rest

packages/accounts/src/journal.ts
├  1:10  — at module level
└  53:15 — inside post
packages/money/src/index.ts
├  3:3 — at module level
├  4:3 — at module level
└  5:3 — at module level
packages/money/tests/money.test.ts
├  2:10  — at module level
├  2:15  — at module level
├  2:38  — at module level
├  5:10  — inside test("adds amounts of one currency exactly") callback
├  9:16  — inside expect() callback
├  9:67  — inside test("refuses to combine currencies") callback
├  13:10 — inside test("formats major and minor units per currency") callback
└  14:10 — inside test("formats major and minor units per currency") callback
packages/reports/src/balance.ts
├  8:10  — at module level
├  34:9  — inside balancesAsOf
└  41:28 — inside balancesAsOf
packages/reports/src/statement.ts
├  2:10  — at module level
└  10:40 — inside statementLine
packages/rules/src/builtin.ts
├  2:10  — at module level
└  28:58 — inside closedPeriodsBalance

Pakete

Entwicklung

vp install
vp run check
vp run check:distribution

CONTRIBUTING.md enthält den Änderungs- und Release-Prozess.