1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
/**
* System-prompt service factory — owns the construct/get decision logic.
*
* Pure-ish: takes a storage namespace + resolver adapters as deps (both
* injectable), so the service is testable with an in-memory storage and fake
* adapters. The real Bun-backed adapters are wired in `extension.ts`.
*/
import type { StorageNamespace } from "@dispatch/kernel";
import { extractVariables, parseTemplate } from "./parser.js";
import type { ResolverAdapters, ResolverContext } from "./resolver.js";
import { resolveVariables } from "./resolver.js";
import type { SystemPromptService } from "./types.js";
/**
* The default template used when no template has been stored. Embeds the
* working directory and an optional `AGENTS.md` (only when the file exists).
*/
export const DEFAULT_TEMPLATE = `You are a helpful coding assistant.
[if file:AGENTS.md]
[file:AGENTS.md]
[endif]
The current working directory is [prompt:cwd].
`;
/** Storage keys. */
const TEMPLATE_KEY = "template";
const resolvedKey = (conversationId: string): string => `resolved:${conversationId}`;
const resolvedCwdKey = (conversationId: string): string => `resolved-cwd:${conversationId}`;
const resolvedComputerIdKey = (conversationId: string): string =>
`resolved-computer:${conversationId}`;
export interface SystemPromptServiceDeps {
/** Namespaced KV (`host.storage("system-prompt")`). */
readonly storage: StorageNamespace;
/** Injected effects for variable resolution (local). */
readonly adapters: ResolverAdapters;
/**
* Optional: build remote-backed adapters for a given computerId. When
* `construct` is called with a `computerId`, this is invoked to obtain
* adapters that read/run commands on the REMOTE machine (via the
* ExecBackend/SSH). Absent → falls back to the local `adapters`.
*/
readonly resolveRemoteAdapters?: (computerId: string, cwd: string) => Promise<ResolverAdapters>;
}
/**
* Resolve a template against the current environment (the shared resolution
* path used by both `construct` — which persists the result — and
* `resolveText`, which does not). Always resolves the fixed catalog
* (`system:*`, `prompt:*`, `git:*`) plus any `file:<path>` keys referenced by
* the template. Selects remote-backed adapters when `context.computerId` is
* set, mirroring `construct`.
*/
async function resolveTemplate(
deps: SystemPromptServiceDeps,
template: string,
cwd: string,
context?: {
readonly model?: string;
readonly conversationId?: string;
readonly workspaceId?: string;
readonly computerId?: string;
},
): Promise<string> {
const referencedKeys = extractVariables(template);
const resolverContext: ResolverContext = {
...(context?.conversationId !== undefined ? { conversationId: context.conversationId } : {}),
...(context?.model !== undefined ? { model: context.model } : {}),
...(context?.workspaceId !== undefined ? { workspaceId: context.workspaceId } : {}),
};
// Select adapters: when computerId is set, use remote-backed adapters
// (read files / run commands on the REMOTE machine via SSH). Otherwise
// use the local adapters.
const computerId = context?.computerId;
const adapters =
computerId !== undefined && deps.resolveRemoteAdapters !== undefined
? await deps.resolveRemoteAdapters(computerId, cwd)
: deps.adapters;
const vars = await resolveVariables(cwd, adapters, {
context: resolverContext,
referencedKeys,
});
return parseTemplate(template, vars);
}
/**
* Create a `SystemPromptService` backed by a storage namespace + adapters.
* State is owned (not ambient): the storage reference lives in this closure.
*/
export function createSystemPromptService(deps: SystemPromptServiceDeps): SystemPromptService {
return {
async construct(conversationId, cwd, context) {
let template = await deps.storage.get(TEMPLATE_KEY);
if (template === null) template = DEFAULT_TEMPLATE;
const result = await resolveTemplate(deps, template, cwd, {
conversationId,
...(context?.model !== undefined ? { model: context.model } : {}),
...(context?.workspaceId !== undefined ? { workspaceId: context.workspaceId } : {}),
...(context?.computerId !== undefined ? { computerId: context.computerId } : {}),
});
await deps.storage.set(resolvedKey(conversationId), result);
await deps.storage.set(resolvedCwdKey(conversationId), cwd);
// Store the computerId (or empty string for local) so the cache can be
// invalidated when the computer changes.
await deps.storage.set(resolvedComputerIdKey(conversationId), context?.computerId ?? "");
return result;
},
async resolveText(template, cwd, context) {
// An empty template has no variables to resolve; short-circuit to
// avoid spawning git / reading files for nothing (the heartbeat's
// default-empty prompts hit this every run).
if (template === "") return "";
return resolveTemplate(deps, template, cwd, context);
},
async get(conversationId) {
return deps.storage.get(resolvedKey(conversationId));
},
async getWithMeta(conversationId) {
const [prompt, cwd, computerIdStored] = await Promise.all([
deps.storage.get(resolvedKey(conversationId)),
deps.storage.get(resolvedCwdKey(conversationId)),
deps.storage.get(resolvedComputerIdKey(conversationId)),
]);
// Empty string → null (local, no computerId). Non-empty → the alias.
const computerId = computerIdStored === null ? null : computerIdStored || null;
return { prompt, cwd, computerId };
},
async getTemplate() {
const stored = await deps.storage.get(TEMPLATE_KEY);
return stored ?? DEFAULT_TEMPLATE;
},
async setTemplate(template) {
await deps.storage.set(TEMPLATE_KEY, template);
},
};
}
|
