@b00dea/cockpit 0.0.0-bootstrap.0 → 0.1.0

package/dist/surfaces/core-declarations.js

@@ -0,0 +1,79 @@
+import { GUARD_SURFACE_TARGETS } from './harness-registry.js';
+import { tryParseJson } from '../environment/contract.js';
+export const CORE_EVALUATOR_ASSET = 'agents/evaluator.agent.md';
+// Each shipped skill installs only its own procedure; one shared copy per skill multiplied the whole
+// procedure by the skill count in every tool's skills directory. The entry point's `procedure`
+// field names the same file, and the skill contract refuses a mismatch.
+export const CORE_SKILL_PROCEDURES = Object.freeze({
+    'cockpit-setup': 'procedures/setup.md',
+    'cockpit-explain': 'procedures/explain.md',
+    'cockpit-fix': 'procedures/fix.md',
+    'cockpit-work': 'procedures/work.md',
+});
+export const CORE_PROCEDURE_ASSETS = Object.freeze([
+    'skills/procedures/setup.md',
+    'skills/procedures/explain.md',
+    'skills/procedures/fix.md',
+    'skills/procedures/work.md',
+]);
+export const CORE_SKILL_ASSETS = Object.freeze([
+    'skills/collection.json',
+    'skills/cockpit-setup.skill.md',
+    'skills/cockpit-explain.skill.md',
+    'skills/cockpit-fix.skill.md',
+    'skills/cockpit-work.skill.md',
+    ...CORE_PROCEDURE_ASSETS,
+]);
+const TOOL_PLACEHOLDER = '{{tool-equivalence}}';
+// The shell tool's name differs per harness, so an entry point names only the tools the cockpit
+// actually renders for; a harness without a guard (no entry here) uses whichever shell it has.
+const SHELL_TOOL = Object.freeze({
+    claudecode: '`Bash` in Claude Code', codexcli: '`shell` in Codex CLI', opencode: '`bash` in OpenCode',
+});
+function toolEquivalenceLine(tools) {
+    // Listed in the harness registry's order, so the sentence does not depend on how `tools` is spelled.
+    const names = GUARD_SURFACE_TARGETS.filter(target => tools.includes(target)).flatMap(target => SHELL_TOOL[target] ?? []);
+    if (names.length === 0)
+        return 'Use your shell tool.';
+    const last = names.at(-1);
+    return `Use ${names.length === 1 ? last : `${names.slice(0, -1).join(', ')}${names.length > 2 ? ',' : ''} or ${last}`}.`;
+}
+function shippedSkillNames(assets) {
+    const bytes = assets.get('skills/collection.json')?.bytes;
+    if (bytes === undefined)
+        return undefined;
+    const parsed = tryParseJson(bytes);
+    const skills = parsed !== null && typeof parsed === 'object' ? parsed.skills : undefined;
+    return Array.isArray(skills) && skills.every(name => typeof name === 'string')
+        ? [...skills]
+        : undefined;
+}
+/** Each shipped skill's entry point and its own procedure, as neutral skill sources. */
+export function shippedSkillSources(assets, tools) {
+    const skills = shippedSkillNames(assets);
+    if (!skills)
+        return undefined;
+    const rows = skills.map(name => {
+        const procedure = CORE_SKILL_PROCEDURES[name];
+        const entry = assets.get(`skills/${name}.skill.md`)?.bytes;
+        const bytes = procedure === undefined ? undefined : assets.get(`skills/${procedure}`)?.bytes;
+        return entry === undefined || bytes === undefined ? undefined : { name, sources: [
+                { path: `skills/${name}/SKILL.md`, bytes: entry.replace(TOOL_PLACEHOLDER, toolEquivalenceLine(tools)) },
+                { path: `skills/${name}/${procedure}`, bytes },
+            ] };
+    });
+    return rows.every(row => row !== undefined) ? rows : undefined;
+}
+export function coreSurfaceDeclarations(assets, tools) {
+    const evaluator = assets.get(CORE_EVALUATOR_ASSET)?.bytes;
+    const skills = shippedSkillSources(assets, tools);
+    if (evaluator === undefined || !skills)
+        return undefined;
+    const declarations = [{
+            name: 'evaluator', feature: 'subagents', source: CORE_EVALUATOR_ASSET,
+            sources: [{ path: 'subagents/evaluator.md', bytes: evaluator }],
+        }, ...skills.map(({ name, sources }) => ({
+            name, feature: 'skills', source: `skills/${name}.skill.md`, sources: sources.map(source => ({ ...source })),
+        }))];
+    return declarations;
+}

package/dist/surfaces/development-markers.d.ts

@@ -0,0 +1 @@
+export declare function stripDevelopmentMarkers(text: string): string;

package/dist/surfaces/development-markers.js

@@ -0,0 +1,18 @@
+// Owns: removing this repository's own maintenance markers from text that is rendered into a
+// consumer's checkout. Must not: touch the shipped source files, because this repository's
+// docs lint and tree hygiene read those markers to keep the templates verified and shipped-only.
+// Hands off to: render.ts, which applies it to every generated file before ownership is planned.
+//
+// Why: a consumer's agent loads these files into every session. A `cockpit:verified version=`
+// line is a bookkeeping claim about cockpit's own docs, and a "SHIPPED SURFACE" note is a
+// message to cockpit maintainers; to the consumer both are noise that costs context and reads
+// as an instruction they cannot act on.
+// Each pattern also eats the blank line that followed the marker, so removal leaves no gap.
+const MARKERS = [
+    /^<!-- cockpit:verified version=\S+ -->\n(?:\n)?/gm,
+    /^<!-- SHIPPED SURFACE\b[^\n]*-->\n(?:\n)?/gm,
+    /^\{\{! SHIPPED SURFACE\b[\s\S]*?\}\}\n(?:\n)?/gm,
+];
+export function stripDevelopmentMarkers(text) {
+    return MARKERS.reduce((current, marker) => current.replace(marker, ''), text);
+}

package/dist/surfaces/generator-adapter.d.ts

@@ -0,0 +1,71 @@
+import { type RenderedSurfaceFile, type SurfaceBundleFormat, type SurfaceTarget } from './contract.js';
+export interface SurfaceGenerationDiagnostic {
+    readonly severity: 'error';
+    readonly code: string;
+    readonly message: string;
+    readonly target?: string;
+    readonly cause: 'input' | 'package' | 'timeout' | 'signal' | 'nonzero' | 'stderr' | 'worker-output' | 'coverage' | 'artifact' | 'cleanup';
+    readonly stderr?: string;
+}
+export interface SurfaceGenerationWarning {
+    readonly severity: 'warning';
+    readonly code: 'SURFACE_GENERATOR_TRUST_WARNING';
+    readonly target: SurfaceTarget;
+    readonly path: '.claude/settings.json';
+    readonly message: string;
+}
+export type SurfaceGenerationOutcome = Readonly<{
+    kind: 'complete';
+    status: 0;
+    diagnostics: readonly [];
+    mechanism: Readonly<{
+        package: 'rulesync';
+        version: typeof RULESYNC_VERSION;
+        role: 'spelling';
+    }>;
+    files: readonly RenderedSurfaceFile[];
+    warnings?: readonly SurfaceGenerationWarning[];
+}> | Readonly<{
+    kind: 'refusal';
+    status: 2;
+    diagnostics: readonly SurfaceGenerationDiagnostic[];
+    files: readonly [];
+}> | Readonly<{
+    kind: 'unavailable';
+    status: 3;
+    diagnostics: readonly SurfaceGenerationDiagnostic[];
+    files: readonly [];
+}>;
+export interface RenderedSurfaceBundleFile {
+    readonly path: string;
+    readonly bytes: string;
+    readonly sha256: string;
+}
+export type SurfaceBundleGenerationOutcome = Readonly<{
+    kind: 'complete';
+    status: 0;
+    diagnostics: readonly [];
+    format: SurfaceBundleFormat;
+    mechanism: Readonly<{
+        package: 'rulesync';
+        version: typeof RULESYNC_VERSION;
+        role: 'packaging';
+    }>;
+    files: readonly RenderedSurfaceBundleFile[];
+}> | Exclude<SurfaceGenerationOutcome, {
+    kind: 'complete';
+}>;
+export type SurfaceEstateGenerationOutcome = Readonly<{
+    kind: 'complete';
+    batch?: Extract<SurfaceGenerationOutcome, {
+        kind: 'complete';
+    }>;
+    bundle?: Extract<SurfaceBundleGenerationOutcome, {
+        kind: 'complete';
+    }>;
+}> | Exclude<SurfaceGenerationOutcome, {
+    kind: 'complete';
+}>;
+export declare const RULESYNC_VERSION = "43.4.2";
+export declare function generateSurfaceEstate(input: unknown): Promise<SurfaceEstateGenerationOutcome>;
+export declare function generateSurfaceBatch(input: unknown): Promise<SurfaceGenerationOutcome>;