@dirgha/code 1.13.2 → 1.14.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/cli/flags.js +15 -14
- package/dist/cli/flags.js.map +1 -1
- package/dist/cli/main.js +232 -124
- package/dist/cli/main.js.map +1 -1
- package/dist/tui/ink/App.d.ts +10 -10
- package/dist/tui/ink/App.js +358 -236
- package/dist/tui/ink/App.js.map +1 -1
- package/dist/tui/ink/components/InputBox.d.ts +4 -2
- package/dist/tui/ink/components/InputBox.js +66 -31
- package/dist/tui/ink/components/InputBox.js.map +1 -1
- package/package.json +1 -1
package/dist/cli/main.js
CHANGED
|
@@ -7,49 +7,49 @@
|
|
|
7
7
|
* and stdin is a TTY, enter the interactive REPL. When stdin is piped,
|
|
8
8
|
* read the prompt from stdin and run non-interactively.
|
|
9
9
|
*/
|
|
10
|
-
import { argv, cwd, exit, stdin, stdout } from
|
|
11
|
-
import { randomUUID } from
|
|
12
|
-
import { createEventStream } from
|
|
13
|
-
import { runAgentLoop } from
|
|
14
|
-
import { ProviderRegistry } from
|
|
15
|
-
import { builtInTools, createToolExecutor, createToolRegistry } from
|
|
16
|
-
import { loadConfig } from
|
|
17
|
-
import { parseFlags } from
|
|
18
|
-
import { runInteractive } from
|
|
19
|
-
import { runInkTUI } from
|
|
20
|
-
import { builtinSlashCommands } from
|
|
21
|
-
import { renderStreamingEvents } from
|
|
22
|
-
import { createSessionStore } from
|
|
23
|
-
import { runSubmitPaper } from
|
|
24
|
-
import { runLogin, runLogout, runSetup, findSubcommand } from
|
|
25
|
-
import { appendAudit } from
|
|
26
|
-
import { buildAgentHooksFromConfig } from
|
|
27
|
-
import { hydrateEnvFromKeyStore } from
|
|
28
|
-
import { hydrateEnvFromPool } from
|
|
29
|
-
import { createExtensionAPI, loadExtensions } from
|
|
30
|
-
import { createErrorClassifier } from
|
|
31
|
-
import { createCompactionTransform } from
|
|
32
|
-
import { contextWindowFor, findPrice, findFailover, resolveModelAlias } from
|
|
33
|
-
import { routeModel } from
|
|
34
|
-
import { loadProjectPrimer, composeSystemPrompt } from
|
|
35
|
-
import { loadSoul } from
|
|
36
|
-
import { modePreamble, resolveMode, isAutoApprove } from
|
|
37
|
-
import { enforceMode, composeHooks } from
|
|
38
|
-
import { loadSkills } from
|
|
39
|
-
import { matchSkills } from
|
|
40
|
-
import { injectSkills } from
|
|
41
|
-
import { createRequire } from
|
|
10
|
+
import { argv, cwd, exit, stdin, stdout } from "node:process";
|
|
11
|
+
import { randomUUID } from "node:crypto";
|
|
12
|
+
import { createEventStream } from "../kernel/event-stream.js";
|
|
13
|
+
import { runAgentLoop } from "../kernel/agent-loop.js";
|
|
14
|
+
import { ProviderRegistry } from "../providers/index.js";
|
|
15
|
+
import { builtInTools, createToolExecutor, createToolRegistry, } from "../tools/index.js";
|
|
16
|
+
import { loadConfig } from "./config.js";
|
|
17
|
+
import { parseFlags } from "./flags.js";
|
|
18
|
+
import { runInteractive } from "./interactive.js";
|
|
19
|
+
import { runInkTUI } from "../tui/ink/index.js";
|
|
20
|
+
import { builtinSlashCommands } from "./slash/index.js";
|
|
21
|
+
import { renderStreamingEvents } from "../tui/renderer.js";
|
|
22
|
+
import { createSessionStore } from "../context/session.js";
|
|
23
|
+
import { runSubmitPaper } from "./submit-paper.js";
|
|
24
|
+
import { runLogin, runLogout, runSetup, findSubcommand, } from "./subcommands/index.js";
|
|
25
|
+
import { appendAudit } from "../audit/writer.js";
|
|
26
|
+
import { buildAgentHooksFromConfig } from "../hooks/config-bridge.js";
|
|
27
|
+
import { hydrateEnvFromKeyStore } from "../auth/keystore.js";
|
|
28
|
+
import { hydrateEnvFromPool } from "../auth/keypool.js";
|
|
29
|
+
import { createExtensionAPI, loadExtensions } from "../extensions/api.js";
|
|
30
|
+
import { createErrorClassifier } from "../intelligence/error-classifier.js";
|
|
31
|
+
import { createCompactionTransform } from "../context/compaction.js";
|
|
32
|
+
import { contextWindowFor, findPrice, findFailover, resolveModelAlias, } from "../intelligence/prices.js";
|
|
33
|
+
import { routeModel } from "../providers/dispatch.js";
|
|
34
|
+
import { loadProjectPrimer, composeSystemPrompt } from "../context/primer.js";
|
|
35
|
+
import { loadSoul } from "../context/soul.js";
|
|
36
|
+
import { modePreamble, resolveMode, isAutoApprove, } from "../context/mode.js";
|
|
37
|
+
import { enforceMode, composeHooks } from "../context/mode-enforcement.js";
|
|
38
|
+
import { loadSkills } from "../skills/loader.js";
|
|
39
|
+
import { matchSkills } from "../skills/matcher.js";
|
|
40
|
+
import { injectSkills } from "../skills/runtime.js";
|
|
41
|
+
import { createRequire } from "node:module";
|
|
42
42
|
// `--version` / `-V` prints the package version and exits, matching every
|
|
43
43
|
// other CLI on the planet. Without this, the flag-parser strips `--version`
|
|
44
44
|
// as a generic boolean and falls through to the interactive REPL.
|
|
45
45
|
const PKG_VERSION = (() => {
|
|
46
46
|
try {
|
|
47
47
|
const req = createRequire(import.meta.url);
|
|
48
|
-
const pkg = req(
|
|
49
|
-
return typeof pkg.version ===
|
|
48
|
+
const pkg = req("../../package.json");
|
|
49
|
+
return typeof pkg.version === "string" ? pkg.version : "0.0.0-dev";
|
|
50
50
|
}
|
|
51
51
|
catch {
|
|
52
|
-
return
|
|
52
|
+
return "0.0.0-dev";
|
|
53
53
|
}
|
|
54
54
|
})();
|
|
55
55
|
async function main() {
|
|
@@ -75,58 +75,72 @@ async function main() {
|
|
|
75
75
|
// Loading failures are non-fatal — the failing extension is named on
|
|
76
76
|
// stderr and the rest of the CLI continues.
|
|
77
77
|
const { api: extAPI, registry: extRegistry } = createExtensionAPI();
|
|
78
|
-
const { join: pathJoin } = await import(
|
|
79
|
-
const { homedir: hd } = await import(
|
|
80
|
-
const extResult = await loadExtensions({
|
|
78
|
+
const { join: pathJoin } = await import("node:path");
|
|
79
|
+
const { homedir: hd } = await import("node:os");
|
|
80
|
+
const extResult = await loadExtensions({
|
|
81
|
+
rootDir: pathJoin(hd(), ".dirgha", "extensions"),
|
|
82
|
+
api: extAPI,
|
|
83
|
+
});
|
|
81
84
|
for (const f of extResult.failed) {
|
|
82
85
|
process.stderr.write(`[extensions] ${f.name} failed to load: ${f.error.message}\n`);
|
|
83
86
|
}
|
|
84
87
|
void extRegistry; // surface for downstream wiring (slashes / tools / events)
|
|
85
88
|
// Subcommand dispatch (positional 0 as verb).
|
|
86
|
-
if (positionals[0] ===
|
|
89
|
+
if (positionals[0] === "submit-paper") {
|
|
87
90
|
const doi = positionals[1];
|
|
88
91
|
if (!doi) {
|
|
89
|
-
stdout.write(
|
|
92
|
+
stdout.write("usage: dirgha submit-paper <doi> [--open-pr]\n");
|
|
90
93
|
exit(1);
|
|
91
94
|
}
|
|
92
|
-
const code = await runSubmitPaper({
|
|
95
|
+
const code = await runSubmitPaper({
|
|
96
|
+
doi,
|
|
97
|
+
openPr: flags["open-pr"] === true,
|
|
98
|
+
});
|
|
93
99
|
exit(code);
|
|
94
100
|
}
|
|
95
101
|
// Pass the RAW argv tail (includes flags like `--provider=...`) so
|
|
96
102
|
// sub-flags survive the top-level parser, the same pattern as fleet.
|
|
97
|
-
if (positionals[0] ===
|
|
103
|
+
if (positionals[0] === "login") {
|
|
98
104
|
const rawArgs = argv.slice(2);
|
|
99
|
-
const verbIdx = rawArgs.indexOf(
|
|
105
|
+
const verbIdx = rawArgs.indexOf("login");
|
|
100
106
|
const tail = verbIdx >= 0 ? rawArgs.slice(verbIdx + 1) : positionals.slice(1);
|
|
101
107
|
exit(await runLogin(tail));
|
|
102
108
|
}
|
|
103
|
-
if (positionals[0] ===
|
|
109
|
+
if (positionals[0] === "logout") {
|
|
104
110
|
const rawArgs = argv.slice(2);
|
|
105
|
-
const verbIdx = rawArgs.indexOf(
|
|
111
|
+
const verbIdx = rawArgs.indexOf("logout");
|
|
106
112
|
const tail = verbIdx >= 0 ? rawArgs.slice(verbIdx + 1) : positionals.slice(1);
|
|
107
113
|
exit(await runLogout(tail));
|
|
108
114
|
}
|
|
109
|
-
if (positionals[0] ===
|
|
115
|
+
if (positionals[0] === "setup")
|
|
110
116
|
exit(await runSetup(positionals.slice(1)));
|
|
111
|
-
if (positionals[0] ===
|
|
117
|
+
if (positionals[0] === "fleet") {
|
|
112
118
|
// `dirgha fleet <launch|list|merge|discard|triple|cleanup>` —
|
|
113
119
|
// parallel-agent orchestration in git worktrees. We pass the
|
|
114
120
|
// RAW argv tail (positionals + flags) so the fleet dispatcher
|
|
115
121
|
// can read its own subcommand-specific flags like --single,
|
|
116
122
|
// --branch=<x>, --auto-merge, --strategy that the top-level
|
|
117
123
|
// parser doesn't know about.
|
|
118
|
-
const { fleetCommand } = await import(
|
|
124
|
+
const { fleetCommand } = await import("../fleet/cli-command.js");
|
|
119
125
|
const config = await loadConfig(cwd());
|
|
120
126
|
const rawArgs = argv.slice(2);
|
|
121
|
-
const verbIdx = rawArgs.indexOf(
|
|
127
|
+
const verbIdx = rawArgs.indexOf("fleet");
|
|
122
128
|
const tail = verbIdx >= 0 ? rawArgs.slice(verbIdx + 1) : positionals.slice(1);
|
|
123
129
|
const code = await fleetCommand(tail, {
|
|
124
130
|
cwd: cwd(),
|
|
125
|
-
model: resolveModelAlias(typeof flags.model ===
|
|
131
|
+
model: resolveModelAlias(typeof flags.model === "string"
|
|
132
|
+
? flags.model
|
|
133
|
+
: typeof flags.m === "string"
|
|
134
|
+
? flags.m
|
|
135
|
+
: config.model),
|
|
126
136
|
json: flags.json === true,
|
|
127
137
|
verbose: flags.verbose === true,
|
|
128
|
-
maxTurns: typeof flags[
|
|
129
|
-
|
|
138
|
+
maxTurns: typeof flags["max-turns"] === "string"
|
|
139
|
+
? Number.parseInt(flags["max-turns"], 10)
|
|
140
|
+
: config.maxTurns,
|
|
141
|
+
concurrency: typeof flags.concurrency === "string"
|
|
142
|
+
? Number.parseInt(flags.concurrency, 10)
|
|
143
|
+
: undefined,
|
|
130
144
|
});
|
|
131
145
|
exit(code);
|
|
132
146
|
}
|
|
@@ -153,23 +167,44 @@ async function main() {
|
|
|
153
167
|
// sender's internal 8s budget keeps the request alive in case
|
|
154
168
|
// Node's event loop survives long enough for it to flush.
|
|
155
169
|
try {
|
|
156
|
-
const { trackCommand } = await import(
|
|
170
|
+
const { trackCommand } = await import("../telemetry/sender.js");
|
|
157
171
|
await Promise.race([
|
|
158
172
|
trackCommand(verb, PKG_VERSION),
|
|
159
|
-
new Promise(r => setTimeout(r, 1000)),
|
|
173
|
+
new Promise((r) => setTimeout(r, 1000)),
|
|
160
174
|
]);
|
|
161
175
|
}
|
|
162
|
-
catch {
|
|
176
|
+
catch {
|
|
177
|
+
/* telemetry must never affect the user's command */
|
|
178
|
+
}
|
|
163
179
|
exit(code);
|
|
164
180
|
}
|
|
165
181
|
}
|
|
166
182
|
const config = await loadConfig(cwd());
|
|
167
|
-
|
|
183
|
+
// CLI-level overrides for flags that affect interactive mode too.
|
|
184
|
+
// `--yolo` is the most surface-level form of "skip every approval",
|
|
185
|
+
// more discoverable than `DIRGHA_MODE=yolo`.
|
|
186
|
+
if (flags.yolo === true)
|
|
187
|
+
config.mode = "yolo";
|
|
188
|
+
if (typeof flags.mode === "string" &&
|
|
189
|
+
["plan", "act", "yolo", "verify", "ask"].includes(flags.mode)) {
|
|
190
|
+
config.mode = flags.mode;
|
|
191
|
+
}
|
|
192
|
+
const rawModel = typeof flags.model === "string"
|
|
193
|
+
? flags.model
|
|
194
|
+
: typeof flags.m === "string"
|
|
195
|
+
? flags.m
|
|
196
|
+
: config.model;
|
|
168
197
|
const model = resolveModelAlias(rawModel);
|
|
169
198
|
const json = flags.json === true;
|
|
170
199
|
const print = flags.print === true;
|
|
171
|
-
const system = typeof flags.system ===
|
|
172
|
-
|
|
200
|
+
const system = typeof flags.system === "string"
|
|
201
|
+
? flags.system
|
|
202
|
+
: typeof flags.s === "string"
|
|
203
|
+
? flags.s
|
|
204
|
+
: undefined;
|
|
205
|
+
const maxTurns = typeof flags["max-turns"] === "string"
|
|
206
|
+
? Number.parseInt(flags["max-turns"], 10)
|
|
207
|
+
: config.maxTurns;
|
|
173
208
|
const providers = new ProviderRegistry();
|
|
174
209
|
const sessions = createSessionStore();
|
|
175
210
|
// Load MCP servers from config and bridge their tools into the
|
|
@@ -179,32 +214,38 @@ async function main() {
|
|
|
179
214
|
const allTools = [...builtInTools];
|
|
180
215
|
let mcpShutdown = async () => { };
|
|
181
216
|
if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
|
|
182
|
-
const { loadMcpServers } = await import(
|
|
217
|
+
const { loadMcpServers } = await import("../mcp/loader.js");
|
|
183
218
|
const mcp = await loadMcpServers(config.mcpServers, {
|
|
184
|
-
onWarn: msg => {
|
|
219
|
+
onWarn: (msg) => {
|
|
220
|
+
process.stderr.write(`warning: ${msg}\n`);
|
|
221
|
+
},
|
|
185
222
|
});
|
|
186
223
|
allTools.push(...mcp.tools);
|
|
187
224
|
mcpShutdown = mcp.shutdown;
|
|
188
225
|
}
|
|
189
226
|
const registry = createToolRegistry(allTools);
|
|
190
|
-
process.once(
|
|
191
|
-
|
|
227
|
+
process.once("exit", () => {
|
|
228
|
+
void mcpShutdown();
|
|
229
|
+
});
|
|
230
|
+
process.once("SIGINT", () => {
|
|
231
|
+
void mcpShutdown().then(() => process.exit(130));
|
|
232
|
+
});
|
|
192
233
|
// Subagent dispatch: register `task` so the model can spawn a fresh
|
|
193
234
|
// agent for a sub-goal. Built lazily so the
|
|
194
235
|
// delegator can capture the now-finalised registry + provider.
|
|
195
|
-
const { SubagentDelegator } = await import(
|
|
196
|
-
const { createTaskTool } = await import(
|
|
236
|
+
const { SubagentDelegator } = await import("../subagents/delegator.js");
|
|
237
|
+
const { createTaskTool } = await import("../tools/task.js");
|
|
197
238
|
// Provider is constructed below; capture via closure so the tool sees
|
|
198
239
|
// the same one. Re-pulled fresh inside execute() so failover swaps work.
|
|
199
240
|
const taskDelegatorRef = { current: null };
|
|
200
241
|
registry.register(createTaskTool({
|
|
201
242
|
delegate: async (req) => {
|
|
202
243
|
if (!taskDelegatorRef.current)
|
|
203
|
-
throw new Error(
|
|
244
|
+
throw new Error("subagent delegator not yet initialised");
|
|
204
245
|
return taskDelegatorRef.current.delegate(req);
|
|
205
246
|
},
|
|
206
247
|
}));
|
|
207
|
-
let prompt = positionals.join(
|
|
248
|
+
let prompt = positionals.join(" ").trim();
|
|
208
249
|
if (!prompt && !stdin.isTTY)
|
|
209
250
|
prompt = (await readAllStdin()).trim();
|
|
210
251
|
if (!prompt) {
|
|
@@ -215,8 +256,8 @@ async function main() {
|
|
|
215
256
|
// First-run wizard: if the user has no BYOK keys saved AND no
|
|
216
257
|
// hosted token, auto-launch the three-step setup flow. The wizard
|
|
217
258
|
// itself prints CI-safe help when stdin is non-TTY.
|
|
218
|
-
if (stdin.isTTY && await isFirstRun()) {
|
|
219
|
-
const { runWizard } = await import(
|
|
259
|
+
if (stdin.isTTY && (await isFirstRun())) {
|
|
260
|
+
const { runWizard } = await import("./flows/wizard.js");
|
|
220
261
|
const code = await runWizard([]);
|
|
221
262
|
// If they completed setup, fall through into the REPL so they
|
|
222
263
|
// can immediately use what they just configured. Otherwise exit.
|
|
@@ -232,22 +273,22 @@ async function main() {
|
|
|
232
273
|
// TERM_PROGRAM=vscode and only use ink when one is present.
|
|
233
274
|
// Override with DIRGHA_FORCE_INK=1 if the user knows their
|
|
234
275
|
// console actually works.
|
|
235
|
-
const explicitNoInk = process.env[
|
|
236
|
-
const explicitForceInk = process.env[
|
|
237
|
-
const onWindowsLegacy = process.platform ===
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
276
|
+
const explicitNoInk = process.env["DIRGHA_NO_INK"] === "1";
|
|
277
|
+
const explicitForceInk = process.env["DIRGHA_FORCE_INK"] === "1";
|
|
278
|
+
const onWindowsLegacy = process.platform === "win32" &&
|
|
279
|
+
!process.env["WT_SESSION"] &&
|
|
280
|
+
process.env["ConEmuANSI"] !== "ON" &&
|
|
281
|
+
process.env["TERM_PROGRAM"] !== "vscode";
|
|
241
282
|
const autoFallbackToReadline = onWindowsLegacy && !explicitForceInk;
|
|
242
283
|
const useInk = !explicitNoInk && !autoFallbackToReadline && stdin.isTTY;
|
|
243
284
|
if (autoFallbackToReadline && !explicitNoInk) {
|
|
244
285
|
// Surface the swap so the user knows why the UI looks different.
|
|
245
|
-
stdout.write(
|
|
246
|
-
|
|
247
|
-
|
|
286
|
+
stdout.write("\x1b[33mNote:\x1b[0m Windows legacy console detected — using readline mode.\n" +
|
|
287
|
+
" For the full Ink TUI, run inside Windows Terminal, the VS Code terminal,\n" +
|
|
288
|
+
" or set \x1b[36mDIRGHA_FORCE_INK=1\x1b[0m to override.\n\n");
|
|
248
289
|
}
|
|
249
290
|
if (useInk) {
|
|
250
|
-
const slashCommands = builtinSlashCommands.map(c => ({
|
|
291
|
+
const slashCommands = builtinSlashCommands.map((c) => ({
|
|
251
292
|
name: c.name,
|
|
252
293
|
description: c.description,
|
|
253
294
|
...(c.aliases !== undefined ? { aliases: c.aliases } : {}),
|
|
@@ -256,18 +297,35 @@ async function main() {
|
|
|
256
297
|
// takes 1-2s during which nothing renders. Without this the user
|
|
257
298
|
// sees a blank screen and assumes the app froze. The line is
|
|
258
299
|
// overdrawn instantly when ink mounts.
|
|
259
|
-
stdout.write(
|
|
260
|
-
await runInkTUI({
|
|
300
|
+
stdout.write("\n Launching dirgha…\n");
|
|
301
|
+
await runInkTUI({
|
|
302
|
+
registry,
|
|
303
|
+
providers,
|
|
304
|
+
sessions,
|
|
305
|
+
config,
|
|
306
|
+
cwd: cwd(),
|
|
307
|
+
systemPrompt: system,
|
|
308
|
+
slashCommands,
|
|
309
|
+
});
|
|
261
310
|
}
|
|
262
311
|
else {
|
|
263
|
-
await runInteractive({
|
|
312
|
+
await runInteractive({
|
|
313
|
+
registry,
|
|
314
|
+
providers,
|
|
315
|
+
sessions,
|
|
316
|
+
config,
|
|
317
|
+
cwd: cwd(),
|
|
318
|
+
systemPrompt: system,
|
|
319
|
+
});
|
|
264
320
|
}
|
|
265
321
|
return;
|
|
266
322
|
}
|
|
267
323
|
const sessionId = randomUUID();
|
|
268
324
|
const events = createEventStream();
|
|
269
325
|
if (json) {
|
|
270
|
-
events.subscribe(ev => {
|
|
326
|
+
events.subscribe((ev) => {
|
|
327
|
+
stdout.write(`${JSON.stringify(ev)}\n`);
|
|
328
|
+
});
|
|
271
329
|
}
|
|
272
330
|
else {
|
|
273
331
|
events.subscribe(renderStreamingEvents({ showThinking: config.showThinking }));
|
|
@@ -285,38 +343,46 @@ async function main() {
|
|
|
285
343
|
const providerId = routeModel(model);
|
|
286
344
|
const price = findPrice(providerId, model);
|
|
287
345
|
const computeCost = (input, output, cached) => price
|
|
288
|
-
? (input / 1_000_000) * price.inputPerM +
|
|
346
|
+
? (input / 1_000_000) * price.inputPerM +
|
|
347
|
+
(output / 1_000_000) * price.outputPerM +
|
|
348
|
+
(cached / 1_000_000) * (price.cachedInputPerM ?? 0)
|
|
289
349
|
: 0;
|
|
290
350
|
events.subscribe(async (ev) => {
|
|
291
351
|
try {
|
|
292
|
-
if (ev.type ===
|
|
352
|
+
if (ev.type === "usage") {
|
|
293
353
|
const cached = ev.cachedTokens ?? 0;
|
|
294
|
-
await session.append({
|
|
354
|
+
await session.append({
|
|
355
|
+
type: "usage",
|
|
356
|
+
ts: sessionTs(),
|
|
357
|
+
usage: {
|
|
295
358
|
inputTokens: ev.inputTokens,
|
|
296
359
|
outputTokens: ev.outputTokens,
|
|
297
360
|
cachedTokens: cached,
|
|
298
361
|
costUsd: computeCost(ev.inputTokens, ev.outputTokens, cached),
|
|
299
|
-
}
|
|
362
|
+
},
|
|
363
|
+
});
|
|
300
364
|
}
|
|
301
365
|
}
|
|
302
|
-
catch {
|
|
366
|
+
catch {
|
|
367
|
+
/* never let persistence I/O break the run */
|
|
368
|
+
}
|
|
303
369
|
});
|
|
304
370
|
// Audit writer: produce entries the `dirgha audit` reader can show.
|
|
305
371
|
// Tool executions, errors, and end-of-turn are the high-signal ones.
|
|
306
|
-
events.subscribe(ev => {
|
|
307
|
-
if (ev.type ===
|
|
372
|
+
events.subscribe((ev) => {
|
|
373
|
+
if (ev.type === "tool_exec_end") {
|
|
308
374
|
void appendAudit({
|
|
309
|
-
kind:
|
|
375
|
+
kind: "tool",
|
|
310
376
|
actor: sessionId,
|
|
311
|
-
summary: `${ev.id} ${ev.isError ?
|
|
377
|
+
summary: `${ev.id} ${ev.isError ? "error" : "done"} ${ev.durationMs}ms`,
|
|
312
378
|
toolId: ev.id,
|
|
313
379
|
isError: ev.isError,
|
|
314
380
|
durationMs: ev.durationMs,
|
|
315
381
|
});
|
|
316
382
|
}
|
|
317
|
-
else if (ev.type ===
|
|
383
|
+
else if (ev.type === "agent_end") {
|
|
318
384
|
void appendAudit({
|
|
319
|
-
kind:
|
|
385
|
+
kind: "turn-end",
|
|
320
386
|
actor: sessionId,
|
|
321
387
|
summary: `model=${model} stop=${ev.stopReason} in=${ev.usage.inputTokens} out=${ev.usage.outputTokens}`,
|
|
322
388
|
model,
|
|
@@ -324,8 +390,12 @@ async function main() {
|
|
|
324
390
|
usage: ev.usage,
|
|
325
391
|
});
|
|
326
392
|
}
|
|
327
|
-
else if (ev.type ===
|
|
328
|
-
void appendAudit({
|
|
393
|
+
else if (ev.type === "error") {
|
|
394
|
+
void appendAudit({
|
|
395
|
+
kind: "error",
|
|
396
|
+
actor: sessionId,
|
|
397
|
+
summary: ev.message,
|
|
398
|
+
});
|
|
329
399
|
}
|
|
330
400
|
});
|
|
331
401
|
const executor = createToolExecutor({ registry, cwd: cwd(), sessionId });
|
|
@@ -339,8 +409,9 @@ async function main() {
|
|
|
339
409
|
// surface-level form of "skip every approval", more discoverable
|
|
340
410
|
// than `DIRGHA_MODE=yolo`.
|
|
341
411
|
if (flags.yolo === true)
|
|
342
|
-
mode =
|
|
343
|
-
if (typeof flags.mode ===
|
|
412
|
+
mode = "yolo";
|
|
413
|
+
if (typeof flags.mode === "string" &&
|
|
414
|
+
["plan", "act", "yolo", "verify", "ask"].includes(flags.mode)) {
|
|
344
415
|
mode = flags.mode;
|
|
345
416
|
}
|
|
346
417
|
const autoApprove = isAutoApprove(mode);
|
|
@@ -348,7 +419,7 @@ async function main() {
|
|
|
348
419
|
// `audit list` can surface every dirgha invocation, not just turns.
|
|
349
420
|
// Lives after mode-resolve so we can include it in the entry.
|
|
350
421
|
void appendAudit({
|
|
351
|
-
kind:
|
|
422
|
+
kind: "session-start",
|
|
352
423
|
actor: sessionId,
|
|
353
424
|
summary: `model=${model} mode=${mode} cwd=${cwd()}`,
|
|
354
425
|
model,
|
|
@@ -368,18 +439,29 @@ async function main() {
|
|
|
368
439
|
userSystem: system,
|
|
369
440
|
});
|
|
370
441
|
const messages = [];
|
|
371
|
-
messages.push({ role:
|
|
372
|
-
messages.push({ role:
|
|
442
|
+
messages.push({ role: "system", content: composedSystem });
|
|
443
|
+
messages.push({ role: "user", content: prompt });
|
|
373
444
|
// Append the user prompt before the turn so a crash mid-stream still
|
|
374
445
|
// leaves a recoverable transcript prefix.
|
|
375
|
-
await session.append({
|
|
376
|
-
|
|
446
|
+
await session.append({
|
|
447
|
+
type: "message",
|
|
448
|
+
ts: sessionTs(),
|
|
449
|
+
message: { role: "user", content: prompt },
|
|
450
|
+
});
|
|
451
|
+
await session.append({
|
|
452
|
+
type: "message",
|
|
453
|
+
ts: sessionTs(),
|
|
454
|
+
message: { role: "system", content: composedSystem },
|
|
455
|
+
});
|
|
377
456
|
// Skills: load all available; inject the ones whose triggers match
|
|
378
457
|
// this turn's user prompt. Project-local skills override user skills
|
|
379
458
|
// when names collide (loadSkills handles that). Skill bodies are
|
|
380
459
|
// injected as a synthetic user message before the live prompt.
|
|
381
460
|
const allSkills = await loadSkills({ cwd: cwd() });
|
|
382
|
-
const matched = matchSkills(allSkills, {
|
|
461
|
+
const matched = matchSkills(allSkills, {
|
|
462
|
+
platform: "cli",
|
|
463
|
+
userMessage: prompt,
|
|
464
|
+
});
|
|
383
465
|
// Provider construction can fail eagerly (e.g. ANTHROPIC_API_KEY
|
|
384
466
|
// unset). When it does AND the user has a known failover model in
|
|
385
467
|
// the registry, swap to that before we even reach the agent loop.
|
|
@@ -394,7 +476,14 @@ async function main() {
|
|
|
394
476
|
if (!fallback)
|
|
395
477
|
throw err;
|
|
396
478
|
process.stderr.write(`\n[failover] ${model} → ${fallback} (${err instanceof Error ? err.message : String(err)})\n`);
|
|
397
|
-
void appendAudit({
|
|
479
|
+
void appendAudit({
|
|
480
|
+
kind: "failover",
|
|
481
|
+
actor: sessionId,
|
|
482
|
+
summary: `${model} → ${fallback}`,
|
|
483
|
+
from: model,
|
|
484
|
+
to: fallback,
|
|
485
|
+
reason: err instanceof Error ? err.message : String(err),
|
|
486
|
+
});
|
|
398
487
|
activeModel = fallback;
|
|
399
488
|
provider = providers.forModel(fallback);
|
|
400
489
|
}
|
|
@@ -422,7 +511,13 @@ async function main() {
|
|
|
422
511
|
const after = r.tokensAfter.toLocaleString();
|
|
423
512
|
const pct = Math.round((1 - r.tokensAfter / r.tokensBefore) * 100);
|
|
424
513
|
process.stderr.write(`\n[compacted] ${before} → ${after} tokens (-${pct}%)\n`);
|
|
425
|
-
void appendAudit({
|
|
514
|
+
void appendAudit({
|
|
515
|
+
kind: "compaction",
|
|
516
|
+
actor: sessionId,
|
|
517
|
+
summary: `${before} → ${after} (-${pct}%)`,
|
|
518
|
+
tokensBefore: r.tokensBefore,
|
|
519
|
+
tokensAfter: r.tokensAfter,
|
|
520
|
+
});
|
|
426
521
|
},
|
|
427
522
|
});
|
|
428
523
|
// Compose: compact first, then inject skills before the live user
|
|
@@ -455,13 +550,20 @@ async function main() {
|
|
|
455
550
|
// continue from the LAST PERSISTED HISTORY (not the original prompt)
|
|
456
551
|
// so multi-turn work doesn't lose progress. Skipped when we already
|
|
457
552
|
// failed over at construction time so we don't double-hop.
|
|
458
|
-
if (result.stopReason ===
|
|
553
|
+
if (result.stopReason === "error" && activeModel === model) {
|
|
459
554
|
const fallback = findFailover(activeModel);
|
|
460
555
|
if (fallback) {
|
|
461
556
|
try {
|
|
462
557
|
const fallbackProvider = providers.forModel(fallback);
|
|
463
558
|
process.stderr.write(`\n[failover] ${activeModel} → ${fallback} (mid-session at turn ${result.turnCount})\n`);
|
|
464
|
-
void appendAudit({
|
|
559
|
+
void appendAudit({
|
|
560
|
+
kind: "failover",
|
|
561
|
+
actor: sessionId,
|
|
562
|
+
summary: `${activeModel} → ${fallback} (turn ${result.turnCount})`,
|
|
563
|
+
from: activeModel,
|
|
564
|
+
to: fallback,
|
|
565
|
+
turn: result.turnCount,
|
|
566
|
+
});
|
|
465
567
|
result = await runAgentLoop({
|
|
466
568
|
sessionId,
|
|
467
569
|
model: fallback,
|
|
@@ -478,7 +580,9 @@ async function main() {
|
|
|
478
580
|
...(composedHooks !== undefined ? { hooks: composedHooks } : {}),
|
|
479
581
|
});
|
|
480
582
|
}
|
|
481
|
-
catch {
|
|
583
|
+
catch {
|
|
584
|
+
/* swallow — original error already reported */
|
|
585
|
+
}
|
|
482
586
|
}
|
|
483
587
|
}
|
|
484
588
|
// Persist every message produced by the turn (assistant turns + tool
|
|
@@ -486,38 +590,42 @@ async function main() {
|
|
|
486
590
|
const initialCount = 2;
|
|
487
591
|
for (const msg of result.messages.slice(initialCount)) {
|
|
488
592
|
try {
|
|
489
|
-
await session.append({ type:
|
|
593
|
+
await session.append({ type: "message", ts: sessionTs(), message: msg });
|
|
594
|
+
}
|
|
595
|
+
catch {
|
|
596
|
+
/* swallow */
|
|
490
597
|
}
|
|
491
|
-
catch { /* swallow */ }
|
|
492
598
|
}
|
|
493
599
|
if (!json)
|
|
494
|
-
stdout.write(
|
|
495
|
-
if (result.stopReason ===
|
|
600
|
+
stdout.write("\n");
|
|
601
|
+
if (result.stopReason === "error")
|
|
496
602
|
exit(2);
|
|
497
603
|
}
|
|
498
604
|
async function isFirstRun() {
|
|
499
|
-
const { stat } = await import(
|
|
500
|
-
const { homedir } = await import(
|
|
501
|
-
const { join } = await import(
|
|
605
|
+
const { stat } = await import("node:fs/promises");
|
|
606
|
+
const { homedir } = await import("node:os");
|
|
607
|
+
const { join } = await import("node:path");
|
|
502
608
|
const home = homedir();
|
|
503
609
|
const candidates = [
|
|
504
|
-
join(home,
|
|
505
|
-
join(home,
|
|
506
|
-
join(home,
|
|
610
|
+
join(home, ".dirgha", "keys.json"),
|
|
611
|
+
join(home, ".dirgha", "credentials.json"),
|
|
612
|
+
join(home, ".dirgha", "config.json"),
|
|
507
613
|
];
|
|
508
614
|
for (const p of candidates) {
|
|
509
|
-
const exists = await stat(p)
|
|
615
|
+
const exists = await stat(p)
|
|
616
|
+
.then(() => true)
|
|
617
|
+
.catch(() => false);
|
|
510
618
|
if (exists)
|
|
511
619
|
return false;
|
|
512
620
|
}
|
|
513
621
|
return true;
|
|
514
622
|
}
|
|
515
623
|
function readAllStdin() {
|
|
516
|
-
return new Promise(resolve => {
|
|
624
|
+
return new Promise((resolve) => {
|
|
517
625
|
const chunks = [];
|
|
518
|
-
stdin.setEncoding(
|
|
519
|
-
stdin.on(
|
|
520
|
-
stdin.on(
|
|
626
|
+
stdin.setEncoding("utf8");
|
|
627
|
+
stdin.on("data", (c) => chunks.push(typeof c === "string" ? c : c.toString("utf8")));
|
|
628
|
+
stdin.on("end", () => resolve(chunks.join("")));
|
|
521
629
|
});
|
|
522
630
|
}
|
|
523
631
|
function printHelp() {
|
|
@@ -548,8 +656,8 @@ Subcommands:
|
|
|
548
656
|
login / logout / setup Auth + first-run wizard
|
|
549
657
|
update [--check] [--yes] Check for + install latest @dirgha/code
|
|
550
658
|
telemetry <status|enable|...> Anonymous usage opt-in (default: OFF)
|
|
551
|
-
scaffold "<prompt>" [--serve] Spin up a new project from a prompt
|
|
552
659
|
submit-paper <doi> Fetch Crossref metadata, emit JSON
|
|
660
|
+
scaffold "<prompt>" [--serve] Spin up a new project from a prompt
|
|
553
661
|
|
|
554
662
|
Options:
|
|
555
663
|
-m, --model <id> Model id (default from config)
|