@gmickel/gno 1.25.1 → 1.26.0

package/src/core/project-affinity-surface.ts

@@ -10,7 +10,10 @@
 import type { Config, ProjectAffinityInput } from "../config/types";
 import type { ProjectAffinityScoringInput } from "../pipeline/project-affinity";
 
+import { PROJECT_AFFINITY_MAX_CONTRIBUTION } from "../config/types";
 import { resolveProjectAffinity } from "./project-affinity";
+import { compileProjectProfileYaml } from "./project-profile";
+import { discoverProjectProfile } from "./project-profile-discovery";
 
 export const MAX_PROJECT_AFFINITY_INPUTS = 16;
 
@@ -19,6 +22,12 @@ export interface CliProjectAffinityRequest {
   projectRoots?: string[];
 }
 
+export interface ProjectProfileAffinityDefaults {
+  contribution: number;
+  enabled: boolean;
+  profileRoot: string;
+}
+
 export class ProjectAffinityInputError extends Error {
   constructor(message: string) {
     super(message);
@@ -66,12 +75,54 @@ const scoringInput = async (
   }),
 });
 
+/**
+ * Resolve only the nearest trusted local profile's compiled affinity defaults.
+ * Invalid/missing profiles are a fallback signal, not a retrieval failure.
+ * Profile content never supplies identity: discovery's canonical profile root
+ * is the sole project root.
+ */
+export const resolveProjectProfileAffinityDefaults = async (
+  cwd: string,
+  config: Config
+): Promise<ProjectProfileAffinityDefaults | null> => {
+  const discovery = await discoverProjectProfile({
+    channel: "local",
+    cwd,
+  });
+  if (
+    discovery.summary.status !== "found" ||
+    !discovery.profilePath ||
+    !discovery.profileRoot
+  ) {
+    return null;
+  }
+
+  try {
+    const profileYaml = await Bun.file(discovery.profilePath).text();
+    const compiled = await compileProjectProfileYaml(profileYaml, {
+      profileRoot: discovery.profileRoot,
+      config,
+    });
+    if (!compiled.ok) return null;
+    return {
+      ...compiled.value.desiredState.affinityDefaults,
+      profileRoot: discovery.profileRoot,
+    };
+  } catch {
+    return null;
+  }
+};
+
 export const resolveCliProjectAffinity = async (
   config: Config,
   options: {
     cwd: string;
     disabled?: boolean;
     projectRoots?: readonly string[];
+    resolveProfileDefaults?: (
+      cwd: string,
+      config: Config
+    ) => Promise<ProjectProfileAffinityDefaults | null>;
   }
 ): Promise<ProjectAffinityScoringInput | undefined> => {
   const projectRoots = normalizeProjectAffinityValues(
@@ -83,16 +134,60 @@ export const resolveCliProjectAffinity = async (
       "--no-project-affinity cannot be combined with --project-root"
     );
   }
-  if (options.disabled || config.projectAffinity?.enabled === false) return;
+  if (options.disabled) return;
 
-  const roots =
-    projectRoots.length > 0
-      ? projectRoots.map((path) => ({
+  if (projectRoots.length > 0) {
+    return scoringInput(
+      {
+        roots: projectRoots.map((path) => ({
           path,
           source: "cli_explicit" as const,
-        }))
-      : [{ path: options.cwd, source: "cli_cwd" as const }];
-  return scoringInput({ roots }, config, "local");
+        })),
+      },
+      {
+        ...config,
+        projectAffinity: {
+          enabled: true,
+          contribution:
+            config.projectAffinity?.contribution ??
+            PROJECT_AFFINITY_MAX_CONTRIBUTION,
+        },
+      },
+      "local"
+    );
+  }
+
+  const profileDefaults = await (
+    options.resolveProfileDefaults ?? resolveProjectProfileAffinityDefaults
+  )(options.cwd, config);
+  if (profileDefaults) {
+    if (!profileDefaults.enabled) return;
+    return scoringInput(
+      {
+        roots: [
+          {
+            path: profileDefaults.profileRoot,
+            source: "project_profile",
+          },
+        ],
+      },
+      {
+        ...config,
+        projectAffinity: {
+          enabled: profileDefaults.enabled,
+          contribution: profileDefaults.contribution,
+        },
+      },
+      "local"
+    );
+  }
+
+  if (config.projectAffinity?.enabled === false) return;
+  return scoringInput(
+    { roots: [{ path: options.cwd, source: "cli_cwd" }] },
+    config,
+    "local"
+  );
 };
 
 export const resolveRemoteProjectAffinity = async (

package/src/core/project-profile-apply-state.ts

@@ -0,0 +1,268 @@
+/**
+ * Pure create/update-only config projection for project profile apply.
+ *
+ * @module src/core/project-profile-apply-state
+ */
+
+import type { Config, ProjectProfileBinding } from "../config/types";
+import type { ProjectProfileDesiredState } from "./project-profile";
+import type { ProjectProfileDiff } from "./project-profile-diff";
+
+import { getPreset } from "../llm/registry";
+import { normalizePersistedContextText } from "./context-identity";
+import {
+  canonicalProjectProfileJson,
+  projectProfileIncludePattern,
+} from "./project-profile";
+
+export type ProjectProfileApplyDisposition =
+  | "created"
+  | "reused"
+  | "updated"
+  | "skipped";
+
+export interface ProjectProfileApplyResource {
+  kind:
+    | "capability"
+    | "collection"
+    | "content_type"
+    | "contexts"
+    | "profile_binding"
+    | "project_affinity"
+    | "stale_mapping";
+  id: string;
+  disposition: ProjectProfileApplyDisposition;
+  pendingIndexing: boolean;
+}
+
+const compareCodeUnits = (left: string, right: string): number =>
+  left < right ? -1 : left > right ? 1 : 0;
+
+export const canonicalProfileStateEqual = (
+  left: unknown,
+  right: unknown
+): boolean =>
+  canonicalProjectProfileJson(left) === canonicalProjectProfileJson(right);
+
+const collectionModels = (
+  config: Config,
+  presetId: string | undefined
+): Config["collections"][number]["models"] | undefined => {
+  if (!presetId) return undefined;
+  const preset = getPreset(config, presetId);
+  if (!preset) return undefined;
+  return {
+    embed: preset.embed,
+    rerank: preset.rerank,
+    ...(preset.expand ? { expand: preset.expand } : {}),
+    gen: preset.gen,
+  };
+};
+
+export function applyProjectProfileDesiredState(
+  config: Config,
+  desired: ProjectProfileDesiredState,
+  collectionRoot: string,
+  profileBinding: ProjectProfileBinding
+): Config {
+  const existingIndex = config.collections.findIndex(
+    (collection) => collection.name === desired.collection.name
+  );
+  const existing =
+    existingIndex >= 0 ? config.collections[existingIndex] : undefined;
+  const models = collectionModels(config, desired.collection.modelPreset);
+  const nextCollection: Config["collections"][number] = {
+    name: desired.collection.name,
+    path: collectionRoot,
+    pattern: projectProfileIncludePattern(desired.collection.include),
+    include: [],
+    exclude: desired.collection.exclude,
+    ...(existing?.updateCmd ? { updateCmd: existing.updateCmd } : {}),
+    ...(desired.collection.languageHint
+      ? { languageHint: desired.collection.languageHint }
+      : existing?.languageHint
+        ? { languageHint: existing.languageHint }
+        : {}),
+    ...(models
+      ? { models }
+      : existing?.models
+        ? { models: existing.models }
+        : {}),
+  };
+  const collections = [...config.collections];
+  if (existingIndex >= 0) collections[existingIndex] = nextCollection;
+  else collections.push(nextCollection);
+
+  const contexts = [...config.contexts];
+  const configuredContexts = new Set(
+    contexts
+      .filter(
+        (context) =>
+          context.scopeType === "collection" &&
+          context.scopeKey === `${desired.collection.name}:`
+      )
+      .map((context) => normalizePersistedContextText(context.text))
+  );
+  for (const context of desired.contexts) {
+    const normalizedText = normalizePersistedContextText(context.text);
+    if (!configuredContexts.has(normalizedText)) {
+      contexts.push({
+        scopeType: context.scopeType,
+        scopeKey: context.scopeKey,
+        text: normalizedText,
+      });
+      configuredContexts.add(normalizedText);
+    }
+  }
+
+  const contentTypes = [...(config.contentTypes ?? [])];
+  for (const desiredRule of desired.contentTypes) {
+    const index = contentTypes.findIndex((rule) => rule.id === desiredRule.id);
+    if (index >= 0) contentTypes[index] = desiredRule;
+    else contentTypes.push(desiredRule);
+  }
+
+  const projectProfileBindings = [...(config.projectProfileBindings ?? [])];
+  const bindingIndex = projectProfileBindings.findIndex(
+    (binding) => binding.path === profileBinding.path
+  );
+  if (bindingIndex >= 0) projectProfileBindings[bindingIndex] = profileBinding;
+  else projectProfileBindings.push(profileBinding);
+  projectProfileBindings.sort((left, right) =>
+    compareCodeUnits(left.path, right.path)
+  );
+
+  return {
+    ...config,
+    collections,
+    contexts,
+    contentTypes,
+    projectProfileBindings,
+  };
+}
+
+export function buildProjectProfileResources(
+  before: Config,
+  after: Config,
+  diff: ProjectProfileDiff,
+  desired: ProjectProfileDesiredState,
+  profileBinding: ProjectProfileBinding
+): ProjectProfileApplyResource[] {
+  const resources: ProjectProfileApplyResource[] = [];
+  const beforeCollection = before.collections.find(
+    (collection) => collection.name === desired.collection.name
+  );
+  const afterCollection = after.collections.find(
+    (collection) => collection.name === desired.collection.name
+  );
+  resources.push({
+    kind: "collection",
+    id: desired.collection.name,
+    disposition: beforeCollection
+      ? canonicalProfileStateEqual(beforeCollection, afterCollection)
+        ? "reused"
+        : "updated"
+      : "created",
+    pendingIndexing: !canonicalProfileStateEqual(
+      beforeCollection,
+      afterCollection
+    ),
+  });
+
+  const beforeContextTexts = new Set(
+    before.contexts
+      .filter(
+        (context) =>
+          context.scopeType === "collection" &&
+          context.scopeKey === `${desired.collection.name}:`
+      )
+      .map((context) => normalizePersistedContextText(context.text))
+  );
+  const missingContexts = desired.contexts.filter(
+    (context) =>
+      !beforeContextTexts.has(normalizePersistedContextText(context.text))
+  );
+  resources.push({
+    kind: "contexts",
+    id: `${desired.collection.name}:`,
+    disposition:
+      desired.contexts.length === 0
+        ? "skipped"
+        : missingContexts.length === 0
+          ? "reused"
+          : beforeContextTexts.size === 0
+            ? "created"
+            : "updated",
+    pendingIndexing: false,
+  });
+
+  const beforeContentTypes = new Map(
+    (before.contentTypes ?? []).map((rule) => [rule.id, rule])
+  );
+  for (const rule of desired.contentTypes) {
+    const previous = beforeContentTypes.get(rule.id);
+    const disposition = previous
+      ? canonicalProfileStateEqual(previous, rule)
+        ? "reused"
+        : "updated"
+      : "created";
+    resources.push({
+      kind: "content_type",
+      id: rule.id,
+      disposition,
+      pendingIndexing: disposition !== "reused",
+    });
+  }
+  if (desired.contentTypes.length === 0) {
+    resources.push({
+      kind: "content_type",
+      id: "(none declared)",
+      disposition: "skipped",
+      pendingIndexing: false,
+    });
+  }
+
+  resources.push({
+    kind: "profile_binding",
+    id: profileBinding.collection,
+    disposition: (() => {
+      const previous = before.projectProfileBindings?.find(
+        (binding) => binding.path === profileBinding.path
+      );
+      if (!previous) return "created";
+      return canonicalProfileStateEqual(previous, profileBinding)
+        ? "reused"
+        : "updated";
+    })(),
+    pendingIndexing: false,
+  });
+
+  resources.push({
+    kind: "project_affinity",
+    id: "profile",
+    disposition: "skipped",
+    pendingIndexing: false,
+  });
+  for (const capability of desired.recommendedCapabilities) {
+    resources.push({
+      kind: "capability",
+      id: capability,
+      disposition: "skipped",
+      pendingIndexing: false,
+    });
+  }
+  for (const mapping of diff.staleMappings) {
+    resources.push({
+      kind: "stale_mapping",
+      id: mapping.collection,
+      disposition: "skipped",
+      pendingIndexing: false,
+    });
+  }
+  return resources.sort(
+    (left, right) =>
+      compareCodeUnits(left.kind, right.kind) ||
+      compareCodeUnits(left.id, right.id) ||
+      compareCodeUnits(left.disposition, right.disposition)
+  );
+}

package/src/core/project-profile-apply-validation.ts

@@ -0,0 +1,95 @@
+/**
+ * Runtime validation for project-profile apply receipts crossing command
+ * composition boundaries.
+ *
+ * @module src/core/project-profile-apply-validation
+ */
+
+import { z } from "zod";
+
+import type { ProjectProfileApplyReceipt } from "./project-profile-apply";
+
+const diagnosticSchema = z
+  .object({
+    code: z.literal("STALE_PROFILE_MAPPING"),
+    severity: z.literal("warning"),
+    path: z.string(),
+    message: z.string().min(1),
+    remediation: z.string().min(1),
+  })
+  .strict();
+
+const diffSchema = z
+  .object({
+    status: z.enum(["in_sync", "changes_required"]),
+    changes: z.array(
+      z
+        .object({
+          action: z.enum(["add", "update", "repair", "review"]),
+          field: z.string().min(1),
+          destructive: z.literal(false),
+          summary: z.string().min(1),
+        })
+        .strict()
+    ),
+    staleMappings: z.array(
+      z
+        .object({
+          collection: z.string().min(1),
+          reason: z.enum(["name_changed", "root_changed"]),
+          choices: z.tuple([
+            z.literal("repair"),
+            z.literal("remove_explicitly"),
+          ]),
+        })
+        .strict()
+    ),
+  })
+  .strict();
+
+const resourceSchema = z
+  .object({
+    kind: z.enum([
+      "capability",
+      "collection",
+      "content_type",
+      "contexts",
+      "profile_binding",
+      "project_affinity",
+      "stale_mapping",
+    ]),
+    id: z.string().min(1),
+    disposition: z.enum(["created", "reused", "updated", "skipped"]),
+    pendingIndexing: z.boolean(),
+  })
+  .strict();
+
+export const projectProfileApplyReceiptSchema: z.ZodType<ProjectProfileApplyReceipt> =
+  z
+    .object({
+      schemaVersion: z.literal("1.0"),
+      command: z.literal("apply"),
+      status: z.enum(["applied", "unchanged"]),
+      profile: z
+        .object({
+          fingerprint: z.string().regex(/^[a-f0-9]{64}$/),
+        })
+        .strict(),
+      diff: diffSchema,
+      resources: z.array(resourceSchema),
+      pendingIndexing: z.array(z.string().min(1)),
+      diagnostics: z.array(diagnosticSchema),
+    })
+    .strict()
+    .refine(
+      (receipt) =>
+        new Set(receipt.pendingIndexing).size ===
+        receipt.pendingIndexing.length,
+      { path: ["pendingIndexing"], message: "Entries must be unique." }
+    );
+
+export function isProjectProfileApplyReceipt(
+  value: unknown
+): value is ProjectProfileApplyReceipt {
+  return projectProfileApplyReceiptSchema.safeParse(value).success;
+}