@notchlet/cli 0.0.0-stage → 0.1.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/auth.js +380 -0
- package/dist/cli.js +403 -0
- package/dist/guidance-install.js +88 -0
- package/dist/integration.js +806 -0
- package/dist/setup.js +92 -0
- package/guidance/aliases.json +27 -0
- package/guidance/generated/claude-code/notchlet-super/SKILL.md +47 -0
- package/guidance/generated/compatibility.json +87 -0
- package/guidance/generated/manifest.json +18 -0
- package/guidance/generated/opencode/notchlet-super/SKILL.md +47 -0
- package/guidance/notchlet-super.md +47 -0
- package/package.json +1 -6
- package/scripts/generate-guidance.mjs +79 -0
- package/README.md +0 -3
package/dist/setup.js
ADDED
|
@@ -0,0 +1,92 @@
|
|
|
1
|
+
import { createInterface } from 'node:readline/promises';
|
|
2
|
+
import { initWorkspace } from '@notchlet/core';
|
|
3
|
+
import { authCommand, getProfile, readHiddenToken, resolveCredential } from './auth.js';
|
|
4
|
+
import { bindWorkspace, platformApi, setWorkspaceSyncMode } from './integration.js';
|
|
5
|
+
function terminalSetupIO() {
|
|
6
|
+
const input = process.stdin;
|
|
7
|
+
const output = process.stderr;
|
|
8
|
+
const readLine = async (prompt) => {
|
|
9
|
+
if (!input.isTTY || !output.isTTY)
|
|
10
|
+
throw new Error('Interactive setup requires a terminal. Use `notchlet init --local` or run `notchlet init --interactive` in a TTY.');
|
|
11
|
+
const rl = createInterface({ input, output });
|
|
12
|
+
try {
|
|
13
|
+
return await rl.question(prompt);
|
|
14
|
+
}
|
|
15
|
+
finally {
|
|
16
|
+
rl.close();
|
|
17
|
+
}
|
|
18
|
+
};
|
|
19
|
+
return {
|
|
20
|
+
stdin: input,
|
|
21
|
+
stdout: output,
|
|
22
|
+
readLine,
|
|
23
|
+
readSecret: (prompt) => readHiddenToken({ stdin: input, stdout: output }, prompt),
|
|
24
|
+
write: (text) => output.write(`${text}\n`),
|
|
25
|
+
};
|
|
26
|
+
}
|
|
27
|
+
async function choose(io, title, values, label, defaultIndex = 0) {
|
|
28
|
+
if (values.length === 0)
|
|
29
|
+
throw new Error(`No ${title.toLowerCase()} are available for this account.`);
|
|
30
|
+
io.write(title);
|
|
31
|
+
values.forEach((value, index) => io.write(` ${index + 1}) ${label(value)}${index === defaultIndex ? ' (default)' : ''}`));
|
|
32
|
+
while (true) {
|
|
33
|
+
const answer = (await io.readLine(`Choose 1-${values.length}${defaultIndex >= 0 ? ` [${defaultIndex + 1}]` : ''}: `)).trim();
|
|
34
|
+
if (!answer && defaultIndex >= 0)
|
|
35
|
+
return values[defaultIndex];
|
|
36
|
+
const index = Number(answer) - 1;
|
|
37
|
+
if (Number.isInteger(index) && index >= 0 && index < values.length)
|
|
38
|
+
return values[index];
|
|
39
|
+
io.write(`Enter a number from 1 to ${values.length}.`);
|
|
40
|
+
}
|
|
41
|
+
}
|
|
42
|
+
export async function interactiveInit(root, options = {}) {
|
|
43
|
+
const io = options.io ?? terminalSetupIO();
|
|
44
|
+
await initWorkspace(root);
|
|
45
|
+
io.write('Set up this checkout for Notchlet:');
|
|
46
|
+
const mode = await choose(io, 'Choose a mode:', ['local', 'connected'], (value) => value === 'local' ? 'Local-only (offline; no account login)' : 'Connect to a Notchlet account', 0);
|
|
47
|
+
if (mode === 'local')
|
|
48
|
+
return { root, mode: 'local', initialized: true };
|
|
49
|
+
const currentProfile = await getProfile().catch(() => undefined);
|
|
50
|
+
const suggestedServer = process.env.NOTCHLET_SERVER ?? currentProfile?.origin ?? '';
|
|
51
|
+
const serverAnswer = (await io.readLine(`Notchlet server HTTPS origin${suggestedServer ? ` [${suggestedServer}]` : ''}: `)).trim();
|
|
52
|
+
const server = serverAnswer || suggestedServer;
|
|
53
|
+
if (!server)
|
|
54
|
+
throw new Error('A Notchlet server URL is required to connect. The local workspace is initialized and remains usable offline.');
|
|
55
|
+
if (process.env.NOTCHLET_TOKEN?.trim()) {
|
|
56
|
+
throw new Error('Connected interactive setup needs a Notchlet account session. Unset NOTCHLET_TOKEN (a scoped API credential) and rerun `notchlet init`, or use `--local`.');
|
|
57
|
+
}
|
|
58
|
+
let profile = await getProfile(server).catch(() => undefined);
|
|
59
|
+
if (!profile || profile.authMode !== 'user') {
|
|
60
|
+
await authCommand('login', { server, fetch: options.fetch, io, store: options.store, loadStore: options.loadStore, forceUserLogin: true });
|
|
61
|
+
profile = await getProfile(server);
|
|
62
|
+
}
|
|
63
|
+
else {
|
|
64
|
+
try {
|
|
65
|
+
await resolveCredential({ server, fetch: options.fetch, store: options.store, loadStore: options.loadStore });
|
|
66
|
+
}
|
|
67
|
+
catch {
|
|
68
|
+
await authCommand('login', { server, fetch: options.fetch, io, store: options.store, loadStore: options.loadStore, forceUserLogin: true });
|
|
69
|
+
profile = await getProfile(server);
|
|
70
|
+
}
|
|
71
|
+
}
|
|
72
|
+
const api = await platformApi(server, { fetch: options.fetch, store: options.store, loadStore: options.loadStore });
|
|
73
|
+
const organizations = await api.get('/organizations/mine');
|
|
74
|
+
if (!organizations.length)
|
|
75
|
+
return { root, mode: 'local', initialized: true, accountConnected: true, message: 'No organizations are available to this account yet; the checkout remains local-only.' };
|
|
76
|
+
const organization = await choose(io, 'Organizations:', organizations, (item) => `${item.name} (#${item.id})`);
|
|
77
|
+
const products = await api.get(`/products?organizationId=${organization.id}`);
|
|
78
|
+
if (!products.length)
|
|
79
|
+
return { root, mode: 'local', initialized: true, accountConnected: true, organizationId: organization.id, message: 'This organization has no products yet; the checkout remains local-only.' };
|
|
80
|
+
const product = await choose(io, 'Products:', products, (item) => `${item.name}${item.team?.name ? ` · ${item.team.name}` : ''} (#${item.id})`);
|
|
81
|
+
const repositoryResponse = await api.get(`/git/config?productId=${product.id}`);
|
|
82
|
+
const repositories = Array.isArray(repositoryResponse) ? repositoryResponse : repositoryResponse ? [repositoryResponse] : [];
|
|
83
|
+
if (!repositories.length)
|
|
84
|
+
return { root, mode: 'local', initialized: true, accountConnected: true, productId: product.id, message: 'No repositories are connected to this product. Local work remains available; connect a repository before binding for remote sync.' };
|
|
85
|
+
const repository = await choose(io, 'Repositories:', repositories, (item) => `${item.repoLabel ?? `${item.repoOwner ?? ''}/${item.repoName ?? ''}`} · ${item.provider ?? 'Git'} (#${item.id})`);
|
|
86
|
+
const syncMode = await choose(io, 'Sync preference:', ['auto', 'manual'], (value) => value === 'auto' ? 'Automatic on CLI use when online (conflicts remain explicit)' : 'Manual only; sync only when requested', 0);
|
|
87
|
+
const binding = await bindWorkspace(root, { server, productId: product.id, repositoryId: repository.id, fetch: options.fetch, store: options.store, loadStore: options.loadStore });
|
|
88
|
+
await setWorkspaceSyncMode(root, syncMode);
|
|
89
|
+
io.write(`Connected to ${organization.name} / ${product.name} / ${repository.repoLabel ?? repository.repoName}.`);
|
|
90
|
+
io.write(`Sync mode: ${syncMode}.`);
|
|
91
|
+
return { root, mode: 'connected', initialized: true, binding, syncMode };
|
|
92
|
+
}
|
|
@@ -0,0 +1,27 @@
|
|
|
1
|
+
{
|
|
2
|
+
"version": 1,
|
|
3
|
+
"source": "mbintangr/notchlet-skills",
|
|
4
|
+
"aliases": {
|
|
5
|
+
"notchlet-development": {
|
|
6
|
+
"skills": ["notchlet-super"],
|
|
7
|
+
"note": "The state router handles whole-cycle requests; use the phase-specific skills below when the request is limited to one phase."
|
|
8
|
+
},
|
|
9
|
+
"notchlet-backlog-planning": {
|
|
10
|
+
"skills": ["notchlet-plan"],
|
|
11
|
+
"note": "Use the current planning skill."
|
|
12
|
+
},
|
|
13
|
+
"notchlet-delivery": {
|
|
14
|
+
"skills": ["notchlet-deliver"],
|
|
15
|
+
"note": "Use the current delivery skill."
|
|
16
|
+
},
|
|
17
|
+
"notchlet-init": {
|
|
18
|
+
"skills": ["notchlet-mcp"],
|
|
19
|
+
"commands": ["notchlet init"],
|
|
20
|
+
"note": "Local workspace initialization and MCP connection setup are separate actions."
|
|
21
|
+
},
|
|
22
|
+
"notchlet-n8n-migration": {
|
|
23
|
+
"skills": [],
|
|
24
|
+
"note": "Outside the current core mirror; preserve any installed specialization."
|
|
25
|
+
}
|
|
26
|
+
}
|
|
27
|
+
}
|
|
@@ -0,0 +1,47 @@
|
|
|
1
|
+
---
|
|
2
|
+
name: notchlet-super
|
|
3
|
+
description: Route a Notchlet development request from current workspace state; resume existing work without restarting setup or planning.
|
|
4
|
+
---
|
|
5
|
+
|
|
6
|
+
# Notchlet Super — state-aware router
|
|
7
|
+
|
|
8
|
+
Use this skill to route a request to the smallest relevant Notchlet action. Read current state first; do not replay a generic six-phase setup for every request. The local CLI manages local `.notchlet` change records and synchronized snapshots; MCP tools access authorized server state. Keep those state boundaries clear. Ask only for material decisions or actions that need user authorization.
|
|
9
|
+
|
|
10
|
+
## Route from the user's intent
|
|
11
|
+
|
|
12
|
+
- **Explore / investigate (read-only):** inspect the checkout, tests, docs, git state, and relevant bounded MCP context. Do not run `notchlet init`, create/convert a change, edit files, transition tasks, sync, checkpoint, or write backlog state. Exploration works without an initialized `.notchlet` workspace; for local state use `notchlet status` or `notchlet change list` only when useful (both report empty state when no workspace exists).
|
|
13
|
+
- **Plan only (read-only unless asked to persist):** use `notchlet-plan` to clarify outcome, scope, assumptions, dependencies, risks, and verification criteria in the conversation. Planning does not require initialization, an epic→story→task hierarchy, or application/change-artifact writes. Existing server-side planning may use bounded read tools (`notchlet_workspace_context`, `notchlet_workspace_search`, `notchlet_backlog_get`, `notchlet_backlog_list`, `notchlet_backlog_development_context`, and `notchlet_document_list/get`); do not create/update items unless the user asks. `notchlet instructions <change> --action plan` is available only for an existing local change and is informational; it is not required for planning.
|
|
14
|
+
- **Revise:** distinguish revising a proposed plan (keep it read-only unless persistence is requested) from revising an existing local change. For the latter, inspect it with `notchlet change show <id>`, `notchlet status <id>`, and `notchlet instructions <id> --action revise`; preserve stable IDs/progress, edit only requested artifacts, then run `notchlet validate <id>`. The `instructions` action itself is read-only.
|
|
15
|
+
- **Implement:** first confirm scope, requirements, repository, branch, and user edits; read `notchlet status <id>` and `notchlet instructions <id> --action implement` when an existing change applies. Follow `notchlet-implement`; run only relevant project checks and record actual outcomes. Use `notchlet task start <task-id> --change <id> --revision <revision>` and `notchlet task complete <task-id> --change <id> --revision <revision>` for dependency/revision-checked local transitions; do not mark complete before evidence exists. `notchlet task update <change> <task> <status> <revision>` remains available for explicit transitions to any supported task state.
|
|
16
|
+
- **Verify:** use `notchlet instructions <id> --action verify`, `notchlet validate <id>`, and actual repository test/check commands appropriate to the change. Record bounded results with `notchlet evidence record --change <id> --file <evidence.json>`; any `command` field is descriptive and never executed. Link required checks with their IDs in `checkIds`. A successful readiness validation is not a substitute for tests. Keep failed and unrun checks distinct; do not claim verification without observed results.
|
|
17
|
+
- **Continue / resume:** locate current state with `notchlet status [<change>]`, `notchlet change list`, and, for a selected change, `notchlet change show <id>` plus `notchlet instructions <id> --action resume`. Continue only eligible work, preserve existing artifacts/user changes, and do not recreate valid plans or restart setup.
|
|
18
|
+
- **Review:** use `notchlet-review`; distinguish a self-recorded check from independent human review.
|
|
19
|
+
- **Deliver:** use `notchlet-deliver` after implementation, verification, and required review. `notchlet checkpoint --change <id> --name <name>` records a synchronized checkpoint; `notchlet sync status|push|pull --change <id>` inspects or explicitly synchronizes snapshots, and resolve only after reviewing divergence. Server delivery can be evaluated with `development_delivery_create` only when explicitly authorized and with its required idempotency/revision fields. A branch-linked item requires the exact linked PR/MR to be merged and approved before a `DONE` status request. Delivery evaluates existing provider state; it does not merge or deploy.
|
|
20
|
+
|
|
21
|
+
## Reuse current workspace and connection
|
|
22
|
+
|
|
23
|
+
1. Use the nearest initialized `.notchlet` workspace or the user's explicit `--workspace <path>` for change-oriented commands. Exploratory and conversation-only planning do not require one.
|
|
24
|
+
2. If there is no initialized workspace, local reads are side-effect free. Run `notchlet init` only when a requested local change workflow actually requires it and the user approves it; do not assume a separate bootstrap command exists. Never initialize just to explore or plan.
|
|
25
|
+
3. For connected work, use `notchlet doctor` to test authenticated capabilities and identity. Do not probe `/mcp` with an unauthenticated `GET`; Notchlet MCP uses authenticated Streamable HTTP `POST` requests.
|
|
26
|
+
4. Do not transfer numeric product IDs between servers. Rebind only after confirming the intended server/product/repository identity.
|
|
27
|
+
5. Fetch bounded context for the selected backlog item when one is relevant; never dump the entire product to find one item. Missing item/product identity is not a reason to turn an exploratory or local planning request into a backlog hierarchy.
|
|
28
|
+
6. If MCP credentials or connection settings are genuinely missing, use `notchlet-mcp` to configure and verify them; otherwise skip setup and reuse the working binding.
|
|
29
|
+
7. If the requested backlog item or product is not yet identified, use `notchlet-platform`; if the identity is already confirmed, reuse it instead of searching again.
|
|
30
|
+
|
|
31
|
+
## State-aware MCP tool calls
|
|
32
|
+
|
|
33
|
+
The local Notchlet MCP registry exposes these concrete tool names and arguments; use the connected server's `tools/list` schemas as authoritative. Some hosts wrap tool names with a `notchlet_` prefix; call only the exact names actually advertised, and do not assume the new development tools are deployed on every server:
|
|
34
|
+
|
|
35
|
+
- `backlog_development_context({ itemId, section?, cursor?, knownFingerprint?, limit? })` for one bounded item context.
|
|
36
|
+
- `development_changes_list({ productId?, limit?, cursor? })` and `development_change_get({ changeId })` to discover/read changes.
|
|
37
|
+
- `development_instructions_get({ changeId, action, snapshotRevision?, context? })` for server-evaluated instructions tied to a synchronized revision; actions are `plan`, `revise`, `implement`, `verify`, and `resume` and require an existing authorized change.
|
|
38
|
+
- `development_delivery_create({ changeId, expectedRevision, operationId, payloadHash, snapshotRevision, target, backlogStatus?, repositoryRef?, summary? })` for an explicit, idempotent delivery evaluation. `backlogStatus` additionally requires `backlog:write`; query the operation after an uncertain response and use a new operation ID only for a new attempt.
|
|
39
|
+
|
|
40
|
+
The REST API and MCP tools call the same `DevelopmentService`; preserve their expected revisions, operation IDs, payload hashes, scope checks, and error recovery semantics. Do not infer that remote snapshot state represents unsynchronized local edits.
|
|
41
|
+
|
|
42
|
+
## Authorization and handoff
|
|
43
|
+
|
|
44
|
+
- Preserve explicit authorization boundaries. Never push, open/merge a PR, deploy, publish skills, or change remote status merely because a task is complete.
|
|
45
|
+
- Use `notchlet sync status|push|pull --change <id>` for explicit snapshot synchronization. Divergence requires review; use `notchlet sync resolve --change <id> --keep-local` only after reviewing the local artifacts, then retry conditionally.
|
|
46
|
+
- `notchlet checkpoint --change <id> --name <name>` records a synchronized checkpoint; it is not delivery evidence by itself.
|
|
47
|
+
- Local verification, local closure, remote delivery, merge, and deployment are separate outcomes. Never describe merge as deployment or a requested status as successful until the service response confirms it.
|
|
@@ -0,0 +1,87 @@
|
|
|
1
|
+
{
|
|
2
|
+
"skills": {
|
|
3
|
+
"notchlet-deliver": {
|
|
4
|
+
"source": "mbintangr/notchlet-skills",
|
|
5
|
+
"commit": "580fae3cfcf5f46868b2b795fe4ec9e0f629a707",
|
|
6
|
+
"sourceType": "github",
|
|
7
|
+
"skillPath": "skills/notchlet-deliver/SKILL.md",
|
|
8
|
+
"computedHash": "83ec1b278f5c3515b99cfe21fca362b9d9858609fbcd88e3fa9423b39d5d054b"
|
|
9
|
+
},
|
|
10
|
+
"notchlet-implement": {
|
|
11
|
+
"source": "mbintangr/notchlet-skills",
|
|
12
|
+
"commit": "580fae3cfcf5f46868b2b795fe4ec9e0f629a707",
|
|
13
|
+
"sourceType": "github",
|
|
14
|
+
"skillPath": "skills/notchlet-implement/SKILL.md",
|
|
15
|
+
"computedHash": "aa4fd302538905b255074b17e6f6de9663ae075a8058e1c3c56341e00365e878"
|
|
16
|
+
},
|
|
17
|
+
"notchlet-mcp": {
|
|
18
|
+
"source": "mbintangr/notchlet-skills",
|
|
19
|
+
"commit": "f735e9bb3a380dcef13b9aa5954915a2b9523673",
|
|
20
|
+
"sourceType": "github",
|
|
21
|
+
"skillPath": "skills/notchlet-mcp/SKILL.md",
|
|
22
|
+
"computedHash": "97ca3e77f404609c1ca9f06603b9ce767b37667050531d37c8dd998b461b5d88"
|
|
23
|
+
},
|
|
24
|
+
"notchlet-plan": {
|
|
25
|
+
"source": "mbintangr/notchlet-skills",
|
|
26
|
+
"commit": "580fae3cfcf5f46868b2b795fe4ec9e0f629a707",
|
|
27
|
+
"sourceType": "github",
|
|
28
|
+
"skillPath": "skills/notchlet-plan/SKILL.md",
|
|
29
|
+
"computedHash": "3b0152ea2163b658c67a2b6156916059bfd9ff27b61309e386ebf17d4b3d8163"
|
|
30
|
+
},
|
|
31
|
+
"notchlet-platform": {
|
|
32
|
+
"source": "mbintangr/notchlet-skills",
|
|
33
|
+
"commit": "580fae3cfcf5f46868b2b795fe4ec9e0f629a707",
|
|
34
|
+
"sourceType": "github",
|
|
35
|
+
"skillPath": "skills/notchlet-platform/SKILL.md",
|
|
36
|
+
"computedHash": "9eeb5ebb62b9409f5cbc3d82a2576249d6da0e96a60b1d552635cca3b6f2d005"
|
|
37
|
+
},
|
|
38
|
+
"notchlet-review": {
|
|
39
|
+
"source": "mbintangr/notchlet-skills",
|
|
40
|
+
"commit": "580fae3cfcf5f46868b2b795fe4ec9e0f629a707",
|
|
41
|
+
"sourceType": "github",
|
|
42
|
+
"skillPath": "skills/notchlet-review/SKILL.md",
|
|
43
|
+
"computedHash": "1eda20eb785caecdee752db5d24528008cb34e182b2f8e60cf28acfba5ef6063"
|
|
44
|
+
},
|
|
45
|
+
"notchlet-super": {
|
|
46
|
+
"source": "mbintangr/notchlet-skills",
|
|
47
|
+
"commit": "f735e9bb3a380dcef13b9aa5954915a2b9523673",
|
|
48
|
+
"sourceType": "github",
|
|
49
|
+
"skillPath": "skills/notchlet-super/SKILL.md",
|
|
50
|
+
"computedHash": "c9be5a6e97fabc5ad330f2cc417b591e4fe7d2a061691e69784573d4004f0acf"
|
|
51
|
+
}
|
|
52
|
+
},
|
|
53
|
+
"aliases": {
|
|
54
|
+
"notchlet-development": {
|
|
55
|
+
"skills": [
|
|
56
|
+
"notchlet-super"
|
|
57
|
+
],
|
|
58
|
+
"note": "The state router handles whole-cycle requests; use the phase-specific skills below when the request is limited to one phase."
|
|
59
|
+
},
|
|
60
|
+
"notchlet-backlog-planning": {
|
|
61
|
+
"skills": [
|
|
62
|
+
"notchlet-plan"
|
|
63
|
+
],
|
|
64
|
+
"note": "Use the current planning skill."
|
|
65
|
+
},
|
|
66
|
+
"notchlet-delivery": {
|
|
67
|
+
"skills": [
|
|
68
|
+
"notchlet-deliver"
|
|
69
|
+
],
|
|
70
|
+
"note": "Use the current delivery skill."
|
|
71
|
+
},
|
|
72
|
+
"notchlet-init": {
|
|
73
|
+
"skills": [
|
|
74
|
+
"notchlet-mcp"
|
|
75
|
+
],
|
|
76
|
+
"commands": [
|
|
77
|
+
"notchlet init"
|
|
78
|
+
],
|
|
79
|
+
"note": "Local workspace initialization and MCP connection setup are separate actions."
|
|
80
|
+
},
|
|
81
|
+
"notchlet-n8n-migration": {
|
|
82
|
+
"skills": [],
|
|
83
|
+
"note": "Outside the current core mirror; preserve any installed specialization."
|
|
84
|
+
}
|
|
85
|
+
},
|
|
86
|
+
"source": "mbintangr/notchlet-skills"
|
|
87
|
+
}
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
{
|
|
2
|
+
"manifestVersion": 1,
|
|
3
|
+
"source": "guidance/notchlet-super.md",
|
|
4
|
+
"sourceVersion": "0.1.0",
|
|
5
|
+
"sourceSha256": "365ffd35b8eb18cc2535319ddebfc7fc6958e1287532f3d04e8341e0c1e9ef2f",
|
|
6
|
+
"targets": [
|
|
7
|
+
{
|
|
8
|
+
"client": "opencode",
|
|
9
|
+
"path": "guidance/generated/opencode/notchlet-super/SKILL.md",
|
|
10
|
+
"sha256": "365ffd35b8eb18cc2535319ddebfc7fc6958e1287532f3d04e8341e0c1e9ef2f"
|
|
11
|
+
},
|
|
12
|
+
{
|
|
13
|
+
"client": "claude-code",
|
|
14
|
+
"path": "guidance/generated/claude-code/notchlet-super/SKILL.md",
|
|
15
|
+
"sha256": "365ffd35b8eb18cc2535319ddebfc7fc6958e1287532f3d04e8341e0c1e9ef2f"
|
|
16
|
+
}
|
|
17
|
+
]
|
|
18
|
+
}
|
|
@@ -0,0 +1,47 @@
|
|
|
1
|
+
---
|
|
2
|
+
name: notchlet-super
|
|
3
|
+
description: Route a Notchlet development request from current workspace state; resume existing work without restarting setup or planning.
|
|
4
|
+
---
|
|
5
|
+
|
|
6
|
+
# Notchlet Super — state-aware router
|
|
7
|
+
|
|
8
|
+
Use this skill to route a request to the smallest relevant Notchlet action. Read current state first; do not replay a generic six-phase setup for every request. The local CLI manages local `.notchlet` change records and synchronized snapshots; MCP tools access authorized server state. Keep those state boundaries clear. Ask only for material decisions or actions that need user authorization.
|
|
9
|
+
|
|
10
|
+
## Route from the user's intent
|
|
11
|
+
|
|
12
|
+
- **Explore / investigate (read-only):** inspect the checkout, tests, docs, git state, and relevant bounded MCP context. Do not run `notchlet init`, create/convert a change, edit files, transition tasks, sync, checkpoint, or write backlog state. Exploration works without an initialized `.notchlet` workspace; for local state use `notchlet status` or `notchlet change list` only when useful (both report empty state when no workspace exists).
|
|
13
|
+
- **Plan only (read-only unless asked to persist):** use `notchlet-plan` to clarify outcome, scope, assumptions, dependencies, risks, and verification criteria in the conversation. Planning does not require initialization, an epic→story→task hierarchy, or application/change-artifact writes. Existing server-side planning may use bounded read tools (`notchlet_workspace_context`, `notchlet_workspace_search`, `notchlet_backlog_get`, `notchlet_backlog_list`, `notchlet_backlog_development_context`, and `notchlet_document_list/get`); do not create/update items unless the user asks. `notchlet instructions <change> --action plan` is available only for an existing local change and is informational; it is not required for planning.
|
|
14
|
+
- **Revise:** distinguish revising a proposed plan (keep it read-only unless persistence is requested) from revising an existing local change. For the latter, inspect it with `notchlet change show <id>`, `notchlet status <id>`, and `notchlet instructions <id> --action revise`; preserve stable IDs/progress, edit only requested artifacts, then run `notchlet validate <id>`. The `instructions` action itself is read-only.
|
|
15
|
+
- **Implement:** first confirm scope, requirements, repository, branch, and user edits; read `notchlet status <id>` and `notchlet instructions <id> --action implement` when an existing change applies. Follow `notchlet-implement`; run only relevant project checks and record actual outcomes. Use `notchlet task start <task-id> --change <id> --revision <revision>` and `notchlet task complete <task-id> --change <id> --revision <revision>` for dependency/revision-checked local transitions; do not mark complete before evidence exists. `notchlet task update <change> <task> <status> <revision>` remains available for explicit transitions to any supported task state.
|
|
16
|
+
- **Verify:** use `notchlet instructions <id> --action verify`, `notchlet validate <id>`, and actual repository test/check commands appropriate to the change. Record bounded results with `notchlet evidence record --change <id> --file <evidence.json>`; any `command` field is descriptive and never executed. Link required checks with their IDs in `checkIds`. A successful readiness validation is not a substitute for tests. Keep failed and unrun checks distinct; do not claim verification without observed results.
|
|
17
|
+
- **Continue / resume:** locate current state with `notchlet status [<change>]`, `notchlet change list`, and, for a selected change, `notchlet change show <id>` plus `notchlet instructions <id> --action resume`. Continue only eligible work, preserve existing artifacts/user changes, and do not recreate valid plans or restart setup.
|
|
18
|
+
- **Review:** use `notchlet-review`; distinguish a self-recorded check from independent human review.
|
|
19
|
+
- **Deliver:** use `notchlet-deliver` after implementation, verification, and required review. `notchlet checkpoint --change <id> --name <name>` records a synchronized checkpoint; `notchlet sync status|push|pull --change <id>` inspects or explicitly synchronizes snapshots, and resolve only after reviewing divergence. Server delivery can be evaluated with `development_delivery_create` only when explicitly authorized and with its required idempotency/revision fields. A branch-linked item requires the exact linked PR/MR to be merged and approved before a `DONE` status request. Delivery evaluates existing provider state; it does not merge or deploy.
|
|
20
|
+
|
|
21
|
+
## Reuse current workspace and connection
|
|
22
|
+
|
|
23
|
+
1. Use the nearest initialized `.notchlet` workspace or the user's explicit `--workspace <path>` for change-oriented commands. Exploratory and conversation-only planning do not require one.
|
|
24
|
+
2. If there is no initialized workspace, local reads are side-effect free. Run `notchlet init` only when a requested local change workflow actually requires it and the user approves it; do not assume a separate bootstrap command exists. Never initialize just to explore or plan.
|
|
25
|
+
3. For connected work, use `notchlet doctor` to test authenticated capabilities and identity. Do not probe `/mcp` with an unauthenticated `GET`; Notchlet MCP uses authenticated Streamable HTTP `POST` requests.
|
|
26
|
+
4. Do not transfer numeric product IDs between servers. Rebind only after confirming the intended server/product/repository identity.
|
|
27
|
+
5. Fetch bounded context for the selected backlog item when one is relevant; never dump the entire product to find one item. Missing item/product identity is not a reason to turn an exploratory or local planning request into a backlog hierarchy.
|
|
28
|
+
6. If MCP credentials or connection settings are genuinely missing, use `notchlet-mcp` to configure and verify them; otherwise skip setup and reuse the working binding.
|
|
29
|
+
7. If the requested backlog item or product is not yet identified, use `notchlet-platform`; if the identity is already confirmed, reuse it instead of searching again.
|
|
30
|
+
|
|
31
|
+
## State-aware MCP tool calls
|
|
32
|
+
|
|
33
|
+
The local Notchlet MCP registry exposes these concrete tool names and arguments; use the connected server's `tools/list` schemas as authoritative. Some hosts wrap tool names with a `notchlet_` prefix; call only the exact names actually advertised, and do not assume the new development tools are deployed on every server:
|
|
34
|
+
|
|
35
|
+
- `backlog_development_context({ itemId, section?, cursor?, knownFingerprint?, limit? })` for one bounded item context.
|
|
36
|
+
- `development_changes_list({ productId?, limit?, cursor? })` and `development_change_get({ changeId })` to discover/read changes.
|
|
37
|
+
- `development_instructions_get({ changeId, action, snapshotRevision?, context? })` for server-evaluated instructions tied to a synchronized revision; actions are `plan`, `revise`, `implement`, `verify`, and `resume` and require an existing authorized change.
|
|
38
|
+
- `development_delivery_create({ changeId, expectedRevision, operationId, payloadHash, snapshotRevision, target, backlogStatus?, repositoryRef?, summary? })` for an explicit, idempotent delivery evaluation. `backlogStatus` additionally requires `backlog:write`; query the operation after an uncertain response and use a new operation ID only for a new attempt.
|
|
39
|
+
|
|
40
|
+
The REST API and MCP tools call the same `DevelopmentService`; preserve their expected revisions, operation IDs, payload hashes, scope checks, and error recovery semantics. Do not infer that remote snapshot state represents unsynchronized local edits.
|
|
41
|
+
|
|
42
|
+
## Authorization and handoff
|
|
43
|
+
|
|
44
|
+
- Preserve explicit authorization boundaries. Never push, open/merge a PR, deploy, publish skills, or change remote status merely because a task is complete.
|
|
45
|
+
- Use `notchlet sync status|push|pull --change <id>` for explicit snapshot synchronization. Divergence requires review; use `notchlet sync resolve --change <id> --keep-local` only after reviewing the local artifacts, then retry conditionally.
|
|
46
|
+
- `notchlet checkpoint --change <id> --name <name>` records a synchronized checkpoint; it is not delivery evidence by itself.
|
|
47
|
+
- Local verification, local closure, remote delivery, merge, and deployment are separate outcomes. Never describe merge as deployment or a requested status as successful until the service response confirms it.
|
|
@@ -0,0 +1,47 @@
|
|
|
1
|
+
---
|
|
2
|
+
name: notchlet-super
|
|
3
|
+
description: Route a Notchlet development request from current workspace state; resume existing work without restarting setup or planning.
|
|
4
|
+
---
|
|
5
|
+
|
|
6
|
+
# Notchlet Super — state-aware router
|
|
7
|
+
|
|
8
|
+
Use this skill to route a request to the smallest relevant Notchlet action. Read current state first; do not replay a generic six-phase setup for every request. The local CLI manages local `.notchlet` change records and synchronized snapshots; MCP tools access authorized server state. Keep those state boundaries clear. Ask only for material decisions or actions that need user authorization.
|
|
9
|
+
|
|
10
|
+
## Route from the user's intent
|
|
11
|
+
|
|
12
|
+
- **Explore / investigate (read-only):** inspect the checkout, tests, docs, git state, and relevant bounded MCP context. Do not run `notchlet init`, create/convert a change, edit files, transition tasks, sync, checkpoint, or write backlog state. Exploration works without an initialized `.notchlet` workspace; for local state use `notchlet status` or `notchlet change list` only when useful (both report empty state when no workspace exists).
|
|
13
|
+
- **Plan only (read-only unless asked to persist):** use `notchlet-plan` to clarify outcome, scope, assumptions, dependencies, risks, and verification criteria in the conversation. Planning does not require initialization, an epic→story→task hierarchy, or application/change-artifact writes. Existing server-side planning may use bounded read tools (`notchlet_workspace_context`, `notchlet_workspace_search`, `notchlet_backlog_get`, `notchlet_backlog_list`, `notchlet_backlog_development_context`, and `notchlet_document_list/get`); do not create/update items unless the user asks. `notchlet instructions <change> --action plan` is available only for an existing local change and is informational; it is not required for planning.
|
|
14
|
+
- **Revise:** distinguish revising a proposed plan (keep it read-only unless persistence is requested) from revising an existing local change. For the latter, inspect it with `notchlet change show <id>`, `notchlet status <id>`, and `notchlet instructions <id> --action revise`; preserve stable IDs/progress, edit only requested artifacts, then run `notchlet validate <id>`. The `instructions` action itself is read-only.
|
|
15
|
+
- **Implement:** first confirm scope, requirements, repository, branch, and user edits; read `notchlet status <id>` and `notchlet instructions <id> --action implement` when an existing change applies. Follow `notchlet-implement`; run only relevant project checks and record actual outcomes. Use `notchlet task start <task-id> --change <id> --revision <revision>` and `notchlet task complete <task-id> --change <id> --revision <revision>` for dependency/revision-checked local transitions; do not mark complete before evidence exists. `notchlet task update <change> <task> <status> <revision>` remains available for explicit transitions to any supported task state.
|
|
16
|
+
- **Verify:** use `notchlet instructions <id> --action verify`, `notchlet validate <id>`, and actual repository test/check commands appropriate to the change. Record bounded results with `notchlet evidence record --change <id> --file <evidence.json>`; any `command` field is descriptive and never executed. Link required checks with their IDs in `checkIds`. A successful readiness validation is not a substitute for tests. Keep failed and unrun checks distinct; do not claim verification without observed results.
|
|
17
|
+
- **Continue / resume:** locate current state with `notchlet status [<change>]`, `notchlet change list`, and, for a selected change, `notchlet change show <id>` plus `notchlet instructions <id> --action resume`. Continue only eligible work, preserve existing artifacts/user changes, and do not recreate valid plans or restart setup.
|
|
18
|
+
- **Review:** use `notchlet-review`; distinguish a self-recorded check from independent human review.
|
|
19
|
+
- **Deliver:** use `notchlet-deliver` after implementation, verification, and required review. `notchlet checkpoint --change <id> --name <name>` records a synchronized checkpoint; `notchlet sync status|push|pull --change <id>` inspects or explicitly synchronizes snapshots, and resolve only after reviewing divergence. Server delivery can be evaluated with `development_delivery_create` only when explicitly authorized and with its required idempotency/revision fields. A branch-linked item requires the exact linked PR/MR to be merged and approved before a `DONE` status request. Delivery evaluates existing provider state; it does not merge or deploy.
|
|
20
|
+
|
|
21
|
+
## Reuse current workspace and connection
|
|
22
|
+
|
|
23
|
+
1. Use the nearest initialized `.notchlet` workspace or the user's explicit `--workspace <path>` for change-oriented commands. Exploratory and conversation-only planning do not require one.
|
|
24
|
+
2. If there is no initialized workspace, local reads are side-effect free. Run `notchlet init` only when a requested local change workflow actually requires it and the user approves it; do not assume a separate bootstrap command exists. Never initialize just to explore or plan.
|
|
25
|
+
3. For connected work, use `notchlet doctor` to test authenticated capabilities and identity. Do not probe `/mcp` with an unauthenticated `GET`; Notchlet MCP uses authenticated Streamable HTTP `POST` requests.
|
|
26
|
+
4. Do not transfer numeric product IDs between servers. Rebind only after confirming the intended server/product/repository identity.
|
|
27
|
+
5. Fetch bounded context for the selected backlog item when one is relevant; never dump the entire product to find one item. Missing item/product identity is not a reason to turn an exploratory or local planning request into a backlog hierarchy.
|
|
28
|
+
6. If MCP credentials or connection settings are genuinely missing, use `notchlet-mcp` to configure and verify them; otherwise skip setup and reuse the working binding.
|
|
29
|
+
7. If the requested backlog item or product is not yet identified, use `notchlet-platform`; if the identity is already confirmed, reuse it instead of searching again.
|
|
30
|
+
|
|
31
|
+
## State-aware MCP tool calls
|
|
32
|
+
|
|
33
|
+
The local Notchlet MCP registry exposes these concrete tool names and arguments; use the connected server's `tools/list` schemas as authoritative. Some hosts wrap tool names with a `notchlet_` prefix; call only the exact names actually advertised, and do not assume the new development tools are deployed on every server:
|
|
34
|
+
|
|
35
|
+
- `backlog_development_context({ itemId, section?, cursor?, knownFingerprint?, limit? })` for one bounded item context.
|
|
36
|
+
- `development_changes_list({ productId?, limit?, cursor? })` and `development_change_get({ changeId })` to discover/read changes.
|
|
37
|
+
- `development_instructions_get({ changeId, action, snapshotRevision?, context? })` for server-evaluated instructions tied to a synchronized revision; actions are `plan`, `revise`, `implement`, `verify`, and `resume` and require an existing authorized change.
|
|
38
|
+
- `development_delivery_create({ changeId, expectedRevision, operationId, payloadHash, snapshotRevision, target, backlogStatus?, repositoryRef?, summary? })` for an explicit, idempotent delivery evaluation. `backlogStatus` additionally requires `backlog:write`; query the operation after an uncertain response and use a new operation ID only for a new attempt.
|
|
39
|
+
|
|
40
|
+
The REST API and MCP tools call the same `DevelopmentService`; preserve their expected revisions, operation IDs, payload hashes, scope checks, and error recovery semantics. Do not infer that remote snapshot state represents unsynchronized local edits.
|
|
41
|
+
|
|
42
|
+
## Authorization and handoff
|
|
43
|
+
|
|
44
|
+
- Preserve explicit authorization boundaries. Never push, open/merge a PR, deploy, publish skills, or change remote status merely because a task is complete.
|
|
45
|
+
- Use `notchlet sync status|push|pull --change <id>` for explicit snapshot synchronization. Divergence requires review; use `notchlet sync resolve --change <id> --keep-local` only after reviewing the local artifacts, then retry conditionally.
|
|
46
|
+
- `notchlet checkpoint --change <id> --name <name>` records a synchronized checkpoint; it is not delivery evidence by itself.
|
|
47
|
+
- Local verification, local closure, remote delivery, merge, and deployment are separate outcomes. Never describe merge as deployment or a requested status as successful until the service response confirms it.
|
package/package.json
CHANGED
|
@@ -1,6 +1 @@
|
|
|
1
|
-
{
|
|
2
|
-
"name": "@notchlet/cli",
|
|
3
|
-
"version": "0.0.0-stage",
|
|
4
|
-
"stub": true,
|
|
5
|
-
"description": "Temporary package placeholder for staged publishing"
|
|
6
|
-
}
|
|
1
|
+
{"name":"@notchlet/cli","version":"0.1.0","type":"module","engines":{"node":">=22"},"bin":{"notchlet":"./dist/cli.js"},"files":["dist/cli.js","dist/auth.js","dist/integration.js","dist/guidance-install.js","dist/setup.js","guidance","scripts/generate-guidance.mjs"],"scripts":{"build":"tsc -p tsconfig.json","test":"npm run build && node --test dist/*.test.js","prepublishOnly":"npm test","guidance:generate":"node scripts/generate-guidance.mjs"},"dependencies":{"@modelcontextprotocol/sdk":"^1.32.2","@napi-rs/keyring":"^2.1.2","@notchlet/core":"^0.1.0"},"devDependencies":{"@types/node":"^22.15.0","typescript":"^5.8.3"}}
|
|
@@ -0,0 +1,79 @@
|
|
|
1
|
+
import { mkdir, readFile, writeFile } from 'node:fs/promises';
|
|
2
|
+
import { createHash } from 'node:crypto';
|
|
3
|
+
import path from 'node:path';
|
|
4
|
+
import { fileURLToPath } from 'node:url';
|
|
5
|
+
|
|
6
|
+
const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
|
|
7
|
+
const repositoryRoot = path.resolve(packageRoot, '../..');
|
|
8
|
+
const sourcePath = path.join(packageRoot, 'guidance', 'notchlet-super.md');
|
|
9
|
+
const source = await readFile(sourcePath, 'utf8');
|
|
10
|
+
|
|
11
|
+
const requiredCommands = [
|
|
12
|
+
"command === 'init'", "command === 'doctor'", "command === 'workspace'", "command === 'sync'",
|
|
13
|
+
"command === 'checkpoint'", "command === 'instructions'", "command === 'status'", "command === 'task'",
|
|
14
|
+
"command === 'change'", "command === 'validate'", "command === 'backlog'", "command === 'evidence'",
|
|
15
|
+
];
|
|
16
|
+
const cliSource = await readFile(path.join(packageRoot, 'src', 'cli.ts'), 'utf8');
|
|
17
|
+
for (const command of requiredCommands) if (!cliSource.includes(command)) throw new Error(`Guidance references an unavailable CLI command: ${command}`);
|
|
18
|
+
for (const syntax of ['sync status|push|pull|resolve --change', 'checkpoint --change', 'evidence record --change', 'instructions <change> [--action plan|revise|implement|verify|resume]', 'change new <name>', 'change list', 'change show <id>', 'change convert <id>', 'status [change]', 'validate <change>', 'task start <task-id> --change <id> --revision <n>', 'task complete <task-id> --change <id> --revision <n>', 'backlog import <item-id>']) {
|
|
19
|
+
if (!cliSource.includes(syntax)) throw new Error(`Guidance syntax is not present in CLI help: ${syntax}`);
|
|
20
|
+
}
|
|
21
|
+
for (const action of ['plan', 'revise', 'implement', 'verify', 'resume']) {
|
|
22
|
+
if (!cliSource.includes(`'${action}'`)) throw new Error(`Guidance references an unsupported workflow action: ${action}`);
|
|
23
|
+
if (!source.includes(`--action ${action}`)) throw new Error(`Canonical guidance does not reference its declared workflow action: ${action}`);
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
const skillLock = JSON.parse(await readFile(path.join(repositoryRoot, 'skills-lock.json'), 'utf8'));
|
|
27
|
+
const aliases = JSON.parse(await readFile(path.join(packageRoot, 'guidance', 'aliases.json'), 'utf8'));
|
|
28
|
+
const requiredSkills = ['notchlet-mcp', 'notchlet-platform', 'notchlet-plan', 'notchlet-implement', 'notchlet-review', 'notchlet-deliver'];
|
|
29
|
+
for (const skill of requiredSkills) {
|
|
30
|
+
if (!skillLock.skills?.[skill]) throw new Error(`Guidance references a skill missing from skills-lock.json: ${skill}`);
|
|
31
|
+
if (!source.includes(`\`${skill}\``)) throw new Error(`Canonical guidance does not reference its declared skill: ${skill}`);
|
|
32
|
+
}
|
|
33
|
+
for (const [legacy, migration] of Object.entries(aliases.aliases ?? {})) {
|
|
34
|
+
for (const skill of migration.skills ?? []) if (!skillLock.skills?.[skill]) throw new Error(`Alias ${legacy} maps to a skill missing from skills-lock.json: ${skill}`);
|
|
35
|
+
for (const command of migration.commands ?? []) if (!cliSource.includes(command)) throw new Error(`Alias ${legacy} maps to an unsupported CLI command: ${command}`);
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
const toolFiles = [
|
|
39
|
+
path.join(repositoryRoot, 'product-guy-be', 'src', 'mcp', 'tools', 'lifecycle.tools.ts'),
|
|
40
|
+
path.join(repositoryRoot, 'product-guy-be', 'src', 'mcp', 'tools', 'development.tools.ts'),
|
|
41
|
+
];
|
|
42
|
+
const toolSources = await Promise.all(toolFiles.map(file => readFile(file, 'utf8')));
|
|
43
|
+
const requiredTools = {
|
|
44
|
+
backlog_development_context: ['itemId', 'section', 'cursor', 'knownFingerprint', 'limit'],
|
|
45
|
+
development_changes_list: ['productId', 'limit', 'cursor'],
|
|
46
|
+
development_change_get: ['changeId'],
|
|
47
|
+
development_instructions_get: ['changeId', 'action', 'snapshotRevision', 'context'],
|
|
48
|
+
development_delivery_create: ['changeId', 'expectedRevision', 'operationId', 'payloadHash', 'snapshotRevision', 'target', 'backlogStatus', 'repositoryRef', 'summary'],
|
|
49
|
+
};
|
|
50
|
+
for (const [name, args] of Object.entries(requiredTools)) {
|
|
51
|
+
const definition = toolSources.flatMap(text => text.split(/\r?\n/)).find(line => line.includes(`name: '${name}'`));
|
|
52
|
+
if (!definition) throw new Error(`Guidance references an MCP tool not registered by the server: ${name}`);
|
|
53
|
+
for (const arg of args) if (!definition.includes(arg)) throw new Error(`Guidance references unsupported ${name} argument: ${arg}`);
|
|
54
|
+
if (!source.includes(`\`${name}({`)) throw new Error(`Canonical guidance does not reference its declared MCP tool: ${name}`);
|
|
55
|
+
}
|
|
56
|
+
const developmentToolSource = toolSources[1];
|
|
57
|
+
for (const action of ['plan', 'revise', 'implement', 'verify', 'resume']) {
|
|
58
|
+
if (!developmentToolSource.includes(`'${action}'`)) throw new Error(`Guidance references an unsupported development MCP action: ${action}`);
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
if (/notchlet-init|curl\s+[^\n]*\/mcp/i.test(source)) throw new Error('Canonical guidance contains a stale init or unauthenticated MCP GET assumption.');
|
|
62
|
+
if (!/Explore \/ investigate \(read-only\)[\s\S]*?Do not run `notchlet init`/.test(source)) throw new Error('Explore guidance must explicitly be read-only and avoid initialization.');
|
|
63
|
+
if (!/Plan only \(read-only unless asked to persist\)[\s\S]*?does not require initialization, an epic→story→task hierarchy, or application\/change-artifact writes/.test(source)) throw new Error('Planning guidance must be read-only by default and independent of initialization and backlog hierarchy.');
|
|
64
|
+
const targets = [
|
|
65
|
+
path.join(packageRoot, 'guidance', 'generated', 'opencode', 'notchlet-super', 'SKILL.md'),
|
|
66
|
+
path.join(packageRoot, 'guidance', 'generated', 'claude-code', 'notchlet-super', 'SKILL.md'),
|
|
67
|
+
];
|
|
68
|
+
const sourceHash = createHash('sha256').update(source).digest('hex');
|
|
69
|
+
const generated = [];
|
|
70
|
+
for (const target of targets) {
|
|
71
|
+
await mkdir(path.dirname(target), { recursive: true });
|
|
72
|
+
await writeFile(target, source, 'utf8');
|
|
73
|
+
generated.push({ client: target.includes(`${path.sep}opencode${path.sep}`) ? 'opencode' : 'claude-code', path: path.relative(packageRoot, target).replace(/\\/g, '/'), sha256: sourceHash });
|
|
74
|
+
}
|
|
75
|
+
const packageManifest = JSON.parse(await readFile(path.join(packageRoot, 'package.json'), 'utf8'));
|
|
76
|
+
const manifest = { manifestVersion: 1, source: 'guidance/notchlet-super.md', sourceVersion: packageManifest.version, sourceSha256: sourceHash, targets: generated };
|
|
77
|
+
await writeFile(path.join(packageRoot, 'guidance', 'generated', 'manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
|
|
78
|
+
await writeFile(path.join(packageRoot, 'guidance', 'generated', 'compatibility.json'), `${JSON.stringify({ skills: skillLock.skills, aliases: aliases.aliases, source: aliases.source }, null, 2)}\n`, 'utf8');
|
|
79
|
+
console.log(`Generated ${targets.length} state-aware notchlet-super outputs from ${path.relative(repositoryRoot, sourcePath)}.`);
|
package/README.md
DELETED