@theronap/agnoclast-mcp 0.9.319 → 0.9.321
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/lib/release_gate.mjs +1 -1
- package/lib/server.mjs +69 -7
- package/lib/split_render.mjs +57 -3
- package/package.json +1 -1
package/lib/release_gate.mjs
CHANGED
|
@@ -11,7 +11,7 @@
|
|
|
11
11
|
// That is safe because hiding a tool is a courtesy, and every gated route checks its own flag on the server.
|
|
12
12
|
|
|
13
13
|
/** Tools any release flag gates — hidden when the server cannot be asked. Mirror of allGatedTools(). */
|
|
14
|
-
export const GATED_FALLBACK = ['arrivals', 'attach_document', 'document_diff', 'export_page', 'file_arrival', 'file_document', 'find_documents', 'finish_task', 'get_document', 'hand_task', 'handed_tasks', 'hold_task', 'import_document_as_page', 'intake_shadow', 'list_documents', 'my_messages', 'my_tasks', 'pin_document', 'place_split_records', 'read_conversation', 'read_document', 'send_message', 'set_manager', 'set_working_hours', 'split_page', 'split_records', 'store_file', 'tasks_waiting', 'undo_split', 'upload_document_version']
|
|
14
|
+
export const GATED_FALLBACK = ['arrivals', 'attach_document', 'document_diff', 'export_page', 'file_arrival', 'file_document', 'find_documents', 'finish_task', 'get_document', 'hand_task', 'handed_tasks', 'hold_task', 'import_document_as_page', 'intake_shadow', 'list_documents', 'merge_pages', 'my_messages', 'my_tasks', 'pin_document', 'place_split_records', 'read_conversation', 'read_document', 'send_message', 'set_manager', 'set_working_hours', 'split_page', 'split_records', 'store_file', 'tasks_waiting', 'undo_merge', 'undo_split', 'upload_document_version']
|
|
15
15
|
|
|
16
16
|
export const RELEASE_FETCH_TIMEOUT_MS = 2500
|
|
17
17
|
/** A remembered answer older than this is not trusted: a week covers a quiet weekend without hiding tools for long. */
|
package/lib/server.mjs
CHANGED
|
@@ -36,7 +36,7 @@ import { formatSeriesRefusal, formatSeriesUpdated } from './series_render.mjs'
|
|
|
36
36
|
import { formatSends } from './sends_render.mjs'
|
|
37
37
|
import { applyLock, fetchLockState, lockedAnswerFor, lockStateWithin } from './locked_tools.mjs'
|
|
38
38
|
import { applyRelease, fetchReleaseState, releaseStateWithin, rememberReleaseState, rememberedReleaseState } from './release_gate.mjs'
|
|
39
|
-
import { renderPlacement, renderSplitRefusal, renderUndo, renderWorklist } from './split_render.mjs'
|
|
39
|
+
import { renderMerge, renderMergeUndo, renderPlacement, renderSplitRefusal, renderUndo, renderWorklist } from './split_render.mjs'
|
|
40
40
|
import { filterUnshownSettling, renderSettlingV2 } from './settling_shown.mjs'
|
|
41
41
|
import { renderContactBriefing, renderContactCandidates, renderContactList } from './contacts_render.mjs'
|
|
42
42
|
import { renderConversation, renderMessageInbox } from './messages_render.mjs'
|
|
@@ -2957,7 +2957,7 @@ function renderNudge(payload) {
|
|
|
2957
2957
|
const a = out.proposals?.attached
|
|
2958
2958
|
const records = a
|
|
2959
2959
|
? `\nRecords on the source: ${a.candidates} to sort${a.hidden ? ` (${a.hidden} you cannot read)` : ''}` +
|
|
2960
|
-
`${a.viaKeptClaims ? `; ${a.viaKeptClaims} held by
|
|
2960
|
+
`${a.viaKeptClaims ? `; ${a.viaKeptClaims} more are held by routing claims the source keeps — split_records asks whether each claim belongs to the new page too` : ''}.`
|
|
2961
2961
|
: ''
|
|
2962
2962
|
const recordsNext = out.records_next ? `\nRECORDS: ${out.records_next}` : ''
|
|
2963
2963
|
if (out.preview) {
|
|
@@ -2972,7 +2972,7 @@ function renderNudge(payload) {
|
|
|
2972
2972
|
'split_records',
|
|
2973
2973
|
{
|
|
2974
2974
|
title: 'List every record a split must sort',
|
|
2975
|
-
description: 'List EVERY record a split you applied left on its source — the full worklist for place_split_records, not the 20 that split_page names. Page through with `offset` until you have covered `total`. Each line: id, title, source/type, date, approximate length, RECORDING when it is a meeting, transcript or handoff (each long one gets its own reader), and how it is attached (moved_claim = through a routing claim the moved text names;
|
|
2975
|
+
description: 'List EVERY record a split you applied left on its source — the full worklist for place_split_records, not the 20 that split_page names. Page through with `offset` until you have covered `total`. Each line: id, title, source/type, date, approximate length, RECORDING when it is a meeting, transcript or handoff (each long one gets its own reader), and how it is attached (moved_claim = through a routing claim the moved text names; kept_claim = through a claim the source keeps, with the claim named; direct). It also lists each KEPT CLAIM with its record count and sample titles — decide those first (place_split_records `claims`). Records you cannot read are counted, never named. Also says whether the records were already placed or the split was undone. Read-only.',
|
|
2976
2976
|
inputSchema: {
|
|
2977
2977
|
plan: z.string().describe('the `plan` token split_page returned when you applied the split'),
|
|
2978
2978
|
offset: z.number().int().min(0).optional().describe('where to start (default 0); the reply names the next offset'),
|
|
@@ -2997,7 +2997,7 @@ function renderNudge(payload) {
|
|
|
2997
2997
|
'place_split_records',
|
|
2998
2998
|
{
|
|
2999
2999
|
title: 'Place a split\'s records, sorted by a full read',
|
|
3000
|
-
description: 'Place the records of a split you APPLIED, in ONE transaction: child = attach to the child and detach from the source; both = attach to the child too; parent = leave. PROCEDURE, every split: (a) FULL READ — list the whole worklist with split_records. Read EVERY candidate in full with read_record part "all" and max_chars at least its length. Each recording over ~20k chars gets its OWN sub-agent that reads every word: no keyword search, no skimming (a trial agent once keyword-searched two 150k transcripts). BOTH IS THE DEFAULT: a record goes on one page only when its own content clearly rules it out of the other (mostly-about is not enough); one with nothing readable (a header-only email, or a fragment — a stub, bare commit message, pending-summary fragment or one-line chat/status naming no subject of either page) can never rule itself out → both. (b) INBOUND LINKS — grep "[[<source title>]]" in substring mode; judge each link from its snippet; edit_page the ones you may edit to point at the child when they meant the moved text; list the rest for their owners. (c) GOVERNANCE NEVER MOVES — a record governed by the source stays on it even when you say child (it goes on both). Every readable candidate needs a decision (parent leaves it). Idempotent: a second call returns the first result.',
|
|
3000
|
+
description: 'Place the records of a split you APPLIED, in ONE transaction: child = attach to the child and detach from the source; both = attach to the child too; parent = leave. PROCEDURE, every split: (a) FULL READ — list the whole worklist with split_records. Read EVERY candidate in full with read_record part "all" and max_chars at least its length. Each recording over ~20k chars gets its OWN sub-agent that reads every word: no keyword search, no skimming (a trial agent once keyword-searched two 150k transcripts). BOTH IS THE DEFAULT: a record goes on one page only when its own content clearly rules it out of the other (mostly-about is not enough); one with nothing readable (a header-only email, or a fragment — a stub, bare commit message, pending-summary fragment or one-line chat/status naming no subject of either page) can never rule itself out → both. CLAIMS FIRST: for each kept claim split_records lists, decide whether the identifier ALSO belongs to the new page — applies: true and the new page claims it too, every record it holds goes on both, and you need not decide those records; applies: false and its records are read in full like the rest. A claim-held record never leaves the source (child means both). Identity claims (email, phone, thread) are always applies: false. (b) INBOUND LINKS — grep "[[<source title>]]" in substring mode; judge each link from its snippet; edit_page the ones you may edit to point at the child when they meant the moved text; list the rest for their owners. (c) GOVERNANCE NEVER MOVES — a record governed by the source stays on it even when you say child (it goes on both). Every readable candidate needs a decision (parent leaves it). Idempotent: a second call returns the first result.',
|
|
3001
3001
|
inputSchema: {
|
|
3002
3002
|
plan: z.string().describe('the `plan` token of the applied split'),
|
|
3003
3003
|
decisions: z.array(z.object({
|
|
@@ -3005,16 +3005,21 @@ function renderNudge(payload) {
|
|
|
3005
3005
|
placement: z.enum(['child', 'parent', 'both']),
|
|
3006
3006
|
confidence: z.number().min(0).max(1).optional(),
|
|
3007
3007
|
reason: z.string().optional().describe('one line: what in the record decided it'),
|
|
3008
|
-
})).describe('the FULL READ: one decision for EVERY candidate split_records lists'),
|
|
3008
|
+
})).describe('the FULL READ: one decision for EVERY candidate split_records lists, except records held by a claim you mark applies: true'),
|
|
3009
|
+
claims: z.array(z.object({
|
|
3010
|
+
identifier: z.string(),
|
|
3011
|
+
applies: z.boolean().describe('true = the identifier also belongs to the new page: it claims it too'),
|
|
3012
|
+
reason: z.string().optional(),
|
|
3013
|
+
})).optional().describe('one decision for EVERY kept claim split_records lists — made before reading its records'),
|
|
3009
3014
|
},
|
|
3010
3015
|
},
|
|
3011
|
-
async ({ plan, decisions }) => {
|
|
3016
|
+
async ({ plan, decisions, claims }) => {
|
|
3012
3017
|
let res
|
|
3013
3018
|
try {
|
|
3014
3019
|
res = await fetchCortex(`${BASE}/api/brain/split-records`, {
|
|
3015
3020
|
method: 'POST',
|
|
3016
3021
|
headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
|
|
3017
|
-
body: JSON.stringify({ plan, decisions }),
|
|
3022
|
+
body: JSON.stringify({ plan, decisions, ...(claims ? { claims } : {}) }),
|
|
3018
3023
|
})
|
|
3019
3024
|
} catch (e) {
|
|
3020
3025
|
return toolError(`Could not place the split's records: ${e.message}`)
|
|
@@ -3052,6 +3057,63 @@ function renderNudge(payload) {
|
|
|
3052
3057
|
},
|
|
3053
3058
|
)
|
|
3054
3059
|
|
|
3060
|
+
server.registerTool(
|
|
3061
|
+
'merge_pages',
|
|
3062
|
+
{
|
|
3063
|
+
title: 'Merge one topic page into another',
|
|
3064
|
+
description: 'Fold one topic page (the SOURCE) into another (the TARGET), in ONE transaction. Preview first (mode:\'preview\', writes nothing), then apply the plan it returns (mode:\'apply\', plan). What a merge does: the source\'s sections are appended to the target WORD FOR WORD, each under "Merged from <source> — <heading>", keeping their dates (condense the overlap afterwards with merge_sections or edit_page); EVERY record on the source is attached to the target too and the target becomes the governing page of the records the source governed — nothing needs reading, a merge has one destination; the source\'s routing claims move to the target; the source is retired (superseded by the target, never deleted), so links to its title read as superseded. Refused at preview: a person page (use request_person_page_merge), pages in different brains, a page you do not own, and pages with a different tier or different grants — a merge must not change who can read anything, so align them first. undo_merge reverses all of it while neither page has changed.',
|
|
3065
|
+
inputSchema: {
|
|
3066
|
+
source_version: z.string().describe('the `version` read_page prints for the page being folded in (it is retired)'),
|
|
3067
|
+
target_version: z.string().describe('the `version` read_page prints for the page that survives'),
|
|
3068
|
+
mode: z.enum(['preview', 'apply']).describe("'preview' first; then 'apply' with the plan it returned"),
|
|
3069
|
+
plan: z.string().optional().describe('the plan token a preview returned (apply only)'),
|
|
3070
|
+
reason: z.string().describe('why, in one phrase — recorded in page_history on both pages'),
|
|
3071
|
+
},
|
|
3072
|
+
},
|
|
3073
|
+
async ({ source_version, target_version, mode, plan, reason }) => {
|
|
3074
|
+
let res
|
|
3075
|
+
try {
|
|
3076
|
+
res = await fetchCortex(`${BASE}/api/brain/merge-pages`, {
|
|
3077
|
+
method: 'POST',
|
|
3078
|
+
headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
|
|
3079
|
+
body: JSON.stringify({ source_version, target_version, mode, reason, ...(plan ? { plan } : {}) }),
|
|
3080
|
+
})
|
|
3081
|
+
} catch (e) {
|
|
3082
|
+
return toolError(`Could not merge the pages: ${e.message}`)
|
|
3083
|
+
}
|
|
3084
|
+
const out = await res.json().catch(() => null)
|
|
3085
|
+
if (!res.ok || !out?.ok) return toolError(renderSplitRefusal('merge the pages', out, res.status))
|
|
3086
|
+
return { content: [{ type: 'text', text: renderMerge(out) }] }
|
|
3087
|
+
},
|
|
3088
|
+
)
|
|
3089
|
+
|
|
3090
|
+
server.registerTool(
|
|
3091
|
+
'undo_merge',
|
|
3092
|
+
{
|
|
3093
|
+
title: 'Undo a page merge',
|
|
3094
|
+
description: 'Undo a page merge you applied, in ONE transaction: the appended sections come off the target, the source page is current again, governance and routing claims go back to it, and the record attachments the merge added are removed. Refused when either page changed after the merge. Only the member who applied it, and only once.',
|
|
3095
|
+
inputSchema: {
|
|
3096
|
+
plan: z.string().describe('the `plan` token of the applied merge'),
|
|
3097
|
+
reason: z.string().optional().describe('why, in one phrase — recorded in page_history'),
|
|
3098
|
+
},
|
|
3099
|
+
},
|
|
3100
|
+
async ({ plan, reason }) => {
|
|
3101
|
+
let res
|
|
3102
|
+
try {
|
|
3103
|
+
res = await fetchCortex(`${BASE}/api/brain/merge-undo`, {
|
|
3104
|
+
method: 'POST',
|
|
3105
|
+
headers: { Authorization: `Bearer ${TOKEN}`, 'Content-Type': 'application/json' },
|
|
3106
|
+
body: JSON.stringify({ plan, ...(reason ? { reason } : {}) }),
|
|
3107
|
+
})
|
|
3108
|
+
} catch (e) {
|
|
3109
|
+
return toolError(`Could not undo the merge: ${e.message}`)
|
|
3110
|
+
}
|
|
3111
|
+
const out = await res.json().catch(() => null)
|
|
3112
|
+
if (!res.ok || !out?.ok) return toolError(renderSplitRefusal('undo the merge', out, res.status))
|
|
3113
|
+
return { content: [{ type: 'text', text: renderMergeUndo(out) }] }
|
|
3114
|
+
},
|
|
3115
|
+
)
|
|
3116
|
+
|
|
3055
3117
|
server.registerTool(
|
|
3056
3118
|
'snooze_routing_claim',
|
|
3057
3119
|
{
|
package/lib/split_render.mjs
CHANGED
|
@@ -11,7 +11,7 @@ export function worklistLine(r) {
|
|
|
11
11
|
const date = r.occurred_at ? String(r.occurred_at).slice(0, 10) : 'undated'
|
|
12
12
|
const kind = [r.source, r.record_type].filter(Boolean).join('/')
|
|
13
13
|
return `· ${r.id} — ${r.title || '(untitled)'} — ${kind} · ${date} · ${kchars(Number(r.approx_chars) || 0)}` +
|
|
14
|
-
`${r.is_recording ? ' · RECORDING' : ''} · ${r.via}`
|
|
14
|
+
`${r.is_recording ? ' · RECORDING' : ''} · ${r.via}${r.claims?.length ? ` (${r.claims.join(', ')})` : ''}`
|
|
15
15
|
}
|
|
16
16
|
|
|
17
17
|
/** split_records' reply: one page of the worklist. */
|
|
@@ -23,7 +23,17 @@ export function renderWorklist(out) {
|
|
|
23
23
|
`, ${out.recordings} of them recordings.`)
|
|
24
24
|
if (out.child?.title) lines.push(`Child: "${out.child.title}"${out.child.ref ? ` (ref ${out.child.ref})` : ''}.`)
|
|
25
25
|
if (out.hidden) lines.push(`${out.hidden} more you cannot read: counted, never named — their owners decide.`)
|
|
26
|
-
|
|
26
|
+
const kept = Array.isArray(out.kept_claims) ? out.kept_claims : []
|
|
27
|
+
if (kept.length) {
|
|
28
|
+
lines.push('', `CLAIMS FIRST — the source keeps ${kept.length} routing claim(s) that hold ${out.via_kept_claims ?? 0} of these records. ` +
|
|
29
|
+
'Decide each: does the identifier ALSO belong to the new page? (claims: [{identifier, applies}] in place_split_records)')
|
|
30
|
+
for (const c of kept) {
|
|
31
|
+
lines.push(`· ${c.identifier} — ${c.records} record(s)${c.claimable ? '' : ' — identity claim: never moves, read its records'}` +
|
|
32
|
+
(c.samples?.length ? ` — e.g. ${c.samples.map((t) => `"${t}"`).join('; ')}` : ''))
|
|
33
|
+
}
|
|
34
|
+
lines.push('applies: true → the new page claims it too and gets all its records; skip reading them. ' +
|
|
35
|
+
'applies: false → read its records IN FULL like the rest. A claim-held record never leaves the source.')
|
|
36
|
+
}
|
|
27
37
|
if (out.records.length) lines.push('', ...out.records.map(worklistLine), '')
|
|
28
38
|
if (shownTo < out.total) lines.push(`More: split_records with plan "${out.plan}" and offset ${shownTo}.`)
|
|
29
39
|
if (out.undone_at) lines.push(`⚠ This split was UNDONE at ${out.undone_at}.`)
|
|
@@ -44,8 +54,17 @@ export function renderPlacement(out) {
|
|
|
44
54
|
const attached = actions.filter((a) => a.attached_child).length
|
|
45
55
|
const detached = actions.filter((a) => a.detached_source).length
|
|
46
56
|
const kept = actions.filter((a) => a.kept_governing).length
|
|
57
|
+
const keptClaim = actions.filter((a) => a.kept_claim).length
|
|
47
58
|
lines.push(`Attached to the child: ${attached}. Detached from the source: ${detached}.` +
|
|
48
|
-
(kept ? ` ${kept} record(s) GOVERNED by the source stay on it as well — governance never moves in a split.` : '')
|
|
59
|
+
(kept ? ` ${kept} record(s) GOVERNED by the source stay on it as well — governance never moves in a split.` : '') +
|
|
60
|
+
(keptClaim ? ` ${keptClaim} record(s) held by a claim the source keeps stay on it as well.` : ''))
|
|
61
|
+
const claims = Array.isArray(p.claims) ? p.claims : []
|
|
62
|
+
if (claims.length) {
|
|
63
|
+
const yes = claims.filter((c) => c.applies).map((c) => c.identifier)
|
|
64
|
+
const no = claims.filter((c) => !c.applies).map((c) => c.identifier)
|
|
65
|
+
if (yes.length) lines.push(`The new page now claims too: ${yes.join(', ')} — future records with ${yes.length > 1 ? 'these' : 'it'} land on both pages.`)
|
|
66
|
+
if (no.length) lines.push(`Claims kept by the source alone: ${no.join(', ')}.`)
|
|
67
|
+
}
|
|
49
68
|
lines.push('Next: inbound [[links]] to the source that meant the moved text (see split_page). undo_split reverses the whole split.')
|
|
50
69
|
return lines.join('\n')
|
|
51
70
|
}
|
|
@@ -57,6 +76,7 @@ export function renderUndo(out) {
|
|
|
57
76
|
`The source has its sections back (${(out.restoredHeadings ?? []).join(' · ')}); its version is now ${out.sourceVersion}.`,
|
|
58
77
|
out.childRetired ? 'The child page is retired (superseded by the source), not deleted.' : 'The child page was already retired.',
|
|
59
78
|
`Records put back on the source: ${out.reattachedToSource}; taken off the child: ${out.detachedFromChild}.`,
|
|
79
|
+
out.claimsRemoved ? `Routing claims the split gave the child, removed: ${out.claimsRemoved}.` : '',
|
|
60
80
|
out.otherChildRecords ? `⚠ ${out.otherChildRecords} record(s) are still attached to the retired child — the split did not put them there; route them yourself.` : '',
|
|
61
81
|
].filter(Boolean).join('\n')
|
|
62
82
|
}
|
|
@@ -66,3 +86,37 @@ export function renderSplitRefusal(what, out, status) {
|
|
|
66
86
|
const detail = Array.isArray(out?.detail) && out.detail.length ? `\n${out.detail.map((d) => `· ${d}`).join('\n')}` : ''
|
|
67
87
|
return `Could not ${what}: ${out?.error ?? status}${out?.message ? ` — ${out.message}` : ''}${detail}${out?.hint ? `\n${out.hint}` : ''}`
|
|
68
88
|
}
|
|
89
|
+
|
|
90
|
+
// ── Page merge (ADR-0036 phase 3) ──────────────────────────────────────────────────────────────────
|
|
91
|
+
|
|
92
|
+
export function renderMerge(out) {
|
|
93
|
+
const lines = []
|
|
94
|
+
const verb = out.preview ? 'PREVIEW — nothing written' : out.replayed ? 'already applied (this is its first result)' : 'APPLIED'
|
|
95
|
+
lines.push(`Merge "${out.source}" → "${out.target}" (${out.brain}, ${out.tier}) — ${verb}.`)
|
|
96
|
+
lines.push(`Text: ${out.appendedHeadings.length} section(s) appended to "${out.target}" word for word, each under "Merged from ${out.source} — …", with their own dates.`)
|
|
97
|
+
if (out.preview) {
|
|
98
|
+
lines.push(`Records: all ${out.records} on "${out.source}" will also attach to "${out.target}"${out.governed ? `; "${out.target}" becomes the governing page of ${out.governed}` : ''}. No reading needed — a merge has one destination.`)
|
|
99
|
+
lines.push(`Routing claims moving to "${out.target}": ${out.claims.length ? out.claims.join(', ') : 'none'}.`)
|
|
100
|
+
lines.push(`"${out.source}" will be retired (superseded by "${out.target}", never deleted); links to it read as superseded.`)
|
|
101
|
+
lines.push(`Audience unchanged: same tier, same ${out.grants} grant(s).`)
|
|
102
|
+
lines.push(`plan: ${out.plan}`)
|
|
103
|
+
lines.push(`Next: merge_pages with mode:'apply' and plan:'${out.plan}'. Afterwards, condense overlapping sections with merge_sections.`)
|
|
104
|
+
} else {
|
|
105
|
+
lines.push(`Records newly attached to "${out.target}": ${out.records}${out.recordsAlreadyOnTarget ? ` (${out.recordsAlreadyOnTarget} were already there)` : ''}; governance moved: ${out.governed}.`)
|
|
106
|
+
lines.push(`Routing claims moved: ${out.claims.length ? out.claims.join(', ') : 'none'}.`)
|
|
107
|
+
lines.push(`"${out.source}" is retired, superseded by "${out.target}".`)
|
|
108
|
+
lines.push(`"${out.target}" is now version ${out.targetVersion}.`)
|
|
109
|
+
lines.push(`plan: ${out.plan} — undo_merge with this plan reverses all of it while neither page has changed.`)
|
|
110
|
+
lines.push(`Next: read "${out.target}" and condense the "Merged from" sections into the page with merge_sections or edit_page.`)
|
|
111
|
+
}
|
|
112
|
+
return lines.join('\n')
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
export function renderMergeUndo(out) {
|
|
116
|
+
return [
|
|
117
|
+
`Merge undone (${out.brain}): "${out.source}" is current again; "${out.target}" lost the ${out.sectionsRemoved} appended section(s).`,
|
|
118
|
+
`Record attachments the merge added, removed: ${out.recordsDetached}. Governance returned: ${out.governanceRestored}. Routing claims returned: ${out.claimsRestored}.`,
|
|
119
|
+
...(out.laterTargetRecords ? [`${out.laterTargetRecords} record(s) reached "${out.target}" after the merge and stay there.`] : []),
|
|
120
|
+
`Versions now: "${out.source}" ${out.sourceVersion} · "${out.target}" ${out.targetVersion}.`,
|
|
121
|
+
].join('\n')
|
|
122
|
+
}
|
package/package.json
CHANGED