faf-cli 6.10.1 → 6.12.0

package/dist/commands/bench.d.ts

@@ -88,8 +88,11 @@ export interface BenchState {
     cold?: RunRecord;
     faf?: RunRecord;
 }
-/** ✪ receipt — sha256 over the canonical projection; third-party verifiable. */
-export declare function buildReceipt(state: BenchState): {
+/** ✪ receipt — sha256 over the canonical projection; third-party verifiable.
+ *  Includes `repo` so the receipt attests WHICH project was benched — two repos
+ *  that score identically on the same qset get distinct receipts (bench-only;
+ *  independent of the parity/trust score hash). */
+export declare function buildReceipt(state: BenchState, repo?: string): {
     projection: string;
     hash: string;
 };
@@ -100,5 +103,7 @@ export interface BenchOptions {
     tokens?: string;
     model?: string;
     file?: string;
+    submit?: boolean;
+    endpoint?: string;
 }
 export declare function benchCommand(action?: string, answersFile?: string, options?: BenchOptions): void;

package/dist/core/interview.d.ts

@@ -70,3 +70,41 @@ export declare function questionForSlot(path: string): string;
  * interviewed. `data` is the parsed .faf object.
  */
 export declare function interviewForMissing(data: Record<string, unknown>, isEmpty: (value: unknown) => boolean): InterviewQuestion[];
+export interface GoalSeed {
+    what?: string;
+    where?: string;
+    who?: string;
+}
+/**
+ * Seed the human-context slots from the Goal sentence — verbatim facts only.
+ * Returns a partial { what?, where?, who? }; absent keys = "no fact, ask the
+ * human". Never returns why/when/how (not verbatim-extractable from a goal).
+ */
+export declare function seedSixWsFromGoal(goal: string): GoalSeed;
+export type BoxStatus = 'filled' | 'seeded' | 'empty';
+export interface TableOf8Row {
+    n: number;
+    path: string;
+    header: string;
+    question: string;
+    value: string;
+    status: BoxStatus;
+    seeded: boolean;
+}
+export interface TableOf8 {
+    version: string;
+    rows: TableOf8Row[];
+    filledCount: number;
+    seededCount: number;
+    emptyCount: number;
+    complete: boolean;
+}
+/**
+ * Build the Table-of-8 from a .faf object (any/empty) + an optional goal. The
+ * goal seeds WHO/WHAT/WHERE via seedSixWsFromGoal (facts only); WHY/WHEN/HOW are
+ * never seeded. Rows the .faf already fills are 'filled'; goal-seeded ones are
+ * 'seeded' (suggestions); the rest are 'empty' (ask the human). Pure.
+ */
+export declare function buildTableOf8(faf: Record<string, unknown>, opts?: {
+    goal?: string;
+}): TableOf8;

package/dist/detect/assemble.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared .faf assembly pipeline. The full slot-filling flow used to build a
+ * FRESH .faf for a directory:
+ *   detect → interrogate → slotignore inactive categories → Turbo-Cat → Relentless
+ *
+ * Used by BOTH `faf auto` (new-file path) and `faf git` (cloned repo) so they
+ * can't drift — `faf git` previously ran detectStack alone (~33% vs ~75%).
+ */
+/** Build a fresh .faf for `dir` using the full slot-filling pipeline. */
+export declare function assembleFreshFaf(dir: string): Record<string, unknown>;
+/** Fill empty/placeholder slots in `target` with values from `source`.
+ *  `target` wins when its slot is non-empty. Empty here is per `isPlaceholder`
+ *  (covers '', null, undefined, and known placeholder strings) — this is what
+ *  lets interrogated/detected values overwrite the empty-string defaults that
+ *  detectStack writes to human_context. */
+export declare function fillEmpties(target: Record<string, unknown>, source: Record<string, unknown>): Record<string, unknown>;

package/dist/detect/frameworks.d.ts

@@ -0,0 +1,3 @@
+import type { FrameworkSignature } from '../core/types.js';
+/** Data-driven framework signatures — one scanner evaluates all */
+export declare const FRAMEWORKS: FrameworkSignature[];

package/dist/detect/relentless.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Relentless — the 6-W human-context extractor. "Never gives up on finding
+ * context" (the v5 RelentlessContextExtractor), rewritten v6-native + sync and
+ * realigned to FAF's no-guess doctrine: it reads EVERY source (manifest +
+ * README, tiered) but FILLS ONLY from sourced evidence. The v5 INFERRED tiers
+ * (guess from project name / tech stack) are deliberately dropped —
+ * sourced-or-empty; `faf go` is where the human confirms.
+ *
+ * Pairs with Turbo-Cat: Turbo-Cat fills STACK slots from file formats;
+ * Relentless fills the 6 HUMAN-CONTEXT slots (who/what/why/where/when/how) by
+ * reading. WHO is the target AUDIENCE (not the package author — a v5 conflation
+ * this rewrite corrects).
+ */
+export interface SeededContext {
+    who?: string;
+    what?: string;
+    why?: string;
+    where?: string;
+    when?: string;
+    how?: string;
+}
+export declare function relentlessContext(dir: string): SeededContext;

package/dist/detect/scanner.d.ts

@@ -0,0 +1,70 @@
+import type { DetectedFramework } from '../core/types.js';
+interface PackageJson {
+    name?: string;
+    version?: string;
+    description?: string;
+    keywords?: string[];
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    scripts?: Record<string, string>;
+    type?: string;
+    main?: string;
+    types?: string;
+    exports?: unknown;
+    bin?: string | Record<string, string>;
+    private?: boolean;
+    workspaces?: string[] | {
+        packages?: string[];
+    };
+    files?: string[];
+}
+/** Read and parse package.json from a directory */
+export declare function readPackageJson(dir: string): PackageJson | null;
+/** Detect frameworks in a directory */
+export declare function detectFrameworks(dir: string): DetectedFramework[];
+/** Detect the primary language of a project */
+export declare function detectLanguage(dir: string): string;
+/** Project-type detection result + rationale (the #found list).
+ *  Each `found` entry is a human-readable signal that contributed to the
+ *  classification — emitted as a YAML comment by `writeFaf` for transparency
+ *  ("Glass Hood" doctrine: the user sees WHY the cli classified as it did). */
+export interface ProjectTypeDetection {
+    type: string;
+    /** Signals that matched, in order observed. */
+    found: string[];
+}
+/** Detect the project type with rationale. The `found` list captures every
+ *  positive signal that contributed to the classification — used downstream
+ *  by `writeFaf` to render `# found: <list>` next to `type:` in the .faf.
+ *
+ *  Priority order per v6.6.md doctrine (most-specific first). `about` is
+ *  owner-declared, not auto-detected — never matches in this function.
+ *  Rule: SDK keyword takes priority (sdk wins over library/cli/wasm). */
+export declare function detectProjectTypeWithRationale(dir: string): ProjectTypeDetection;
+/** Detect the project type for slot mapping. Backward-compatible wrapper —
+ *  returns just the type string. New code should prefer
+ *  `detectProjectTypeWithRationale` to access the `#found` rationale. */
+export declare function detectProjectType(dir: string): string;
+/** Detect the runtime */
+export declare function detectRuntime(dir: string): string;
+/** Detect package manager */
+export declare function detectPackageManager(dir: string): string;
+/** Detect CI/CD */
+export declare function detectCicd(dir: string): string | null;
+/** Detect hosting platform */
+export declare function detectHosting(dir: string): string | null;
+/** Detect SvelteKit adapter from svelte.config.js */
+export declare function detectSvelteAdapter(dir: string): string | null;
+/** Detect build tool */
+export declare function detectBuildTool(dir: string): string | null;
+/** Detect a list of important file paths for the KEY_FILES FAFB section.
+ *  Returns up to ~10 entries, ordered by canonical importance. */
+export declare function detectKeyFiles(dir: string): string[];
+/** Detect build/test/lint commands for the COMMANDS FAFB section.
+ *  Returns a Record<string, string> mapping command name → shell command. */
+export declare function detectCommands(dir: string, pkg: PackageJson | null): Record<string, string>;
+/** Detect a tech-stack list for the TECH_STACK FAFB section.
+ *  Combines language + frameworks + runtime into a flat list of strings
+ *  (matching the canonical xai-faf-rust project.faf shape). */
+export declare function detectTechStack(dir: string, pkg: PackageJson | null, frameworks: DetectedFramework[], language: string): string[];
+export {};

package/dist/detect/stack.d.ts

@@ -0,0 +1,3 @@
+import type { FafData } from '../core/types.js';
+/** Auto-detect project stack and generate .faf data */
+export declare function detectStack(dir: string): FafData;

package/dist/index.d.ts

@@ -6,10 +6,15 @@ export { enrichScore, scoreFafYaml } from './core/scorer.js';
 export { validateFaf } from './core/schema.js';
 export { findFafFile, readFaf, readFafRaw } from './interop/faf.js';
 export { generateProjectHtml, writeProjectHtml } from './interop/projecthtml.js';
-export type { InterviewQuestion, InterviewOption } from './core/interview.js';
-export { INTERVIEW, SIX_WS_INTERVIEW, STACK_INTERVIEW, INTERVIEW_BY_PATH, INTERVIEW_PATHS, INTERVIEW_VERSION, questionForSlot, interviewForMissing, } from './core/interview.js';
+export { generateServerCard, writeServerCard, fafContextBlock, registryMeta, registryName, REGISTRY_PUBLISHER_KEY, } from './interop/servercard.js';
+export type { ServerCardOptions } from './interop/servercard.js';
+export type { InterviewQuestion, InterviewOption, GoalSeed, TableOf8, TableOf8Row, BoxStatus } from './core/interview.js';
+export { INTERVIEW, SIX_WS_INTERVIEW, STACK_INTERVIEW, INTERVIEW_BY_PATH, INTERVIEW_PATHS, INTERVIEW_VERSION, questionForSlot, interviewForMissing, seedSixWsFromGoal, buildTableOf8, } from './core/interview.js';
 export { BENCH_VERSION, deriveQuestionSet, publicQuestions, gradeAnswers, buildReceipt, normalizeAnswer, answersMatch, ALIAS_GROUPS, } from './commands/bench.js';
 export type { BenchQuestion, QuestionSet, GradeResult, BenchState, RunRecord } from './commands/bench.js';
 export { turboCatScan, turboCatSlots } from './detect/turbo-cat.js';
 export type { TurboCatResult, DiscoveredFormat } from './detect/turbo-cat.js';
+export { relentlessContext } from './detect/relentless.js';
+export type { SeededContext } from './detect/relentless.js';
+export { assembleFreshFaf } from './detect/assemble.js';
 export * as kernel from './wasm/kernel.js';