@turri-dev/cli 0.1.27 → 0.2.0

package/dist/regenerate/paths.d.ts

@@ -1,5 +1,7 @@
 /** A module's code record and its tests' - `code/.turri.json`, `tests/.turri.json` (records.ts). */
 export declare const RECORD_FILE = ".turri.json";
+/** What a codebase started from, when it started from a base folder (base-folder.ts): beside the code record, never code. */
+export declare const BASE_RECORD_FILE = ".turri-base.json";
 /**
  * The ***plain standard library: import modules for generic pieces of software that ship with turri,
  * imported as `stdlib/backend/python-fastapi` - a reserved name (see plain/stdlib.ts).
@@ -35,6 +37,8 @@ export declare function defaultBuildDir(moduleName: string, cwd?: string): strin
  * specs at the root of their project are built where they always were.
  */
 export declare function projectDirOf(plainFile: string): string;
+/** Whether a folder says it is a project: it holds a config file or `plain_modules/`. */
+export declare function isProjectDir(dir: string): boolean;
 export declare function modulesRoot(cwd?: string): string;
 export declare function buildDirUnder(root: string, moduleName: string): string;
 export declare function testsDirUnder(root: string, moduleName: string): string;

package/dist/regenerate/paths.js

@@ -3,6 +3,8 @@ import { dirname, join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 /** A module's code record and its tests' - `code/.turri.json`, `tests/.turri.json` (records.ts). */
 export const RECORD_FILE = ".turri.json";
+/** What a codebase started from, when it started from a base folder (base-folder.ts): beside the code record, never code. */
+export const BASE_RECORD_FILE = ".turri-base.json";
 /**
  * The ***plain standard library: import modules for generic pieces of software that ship with turri,
  * imported as `stdlib/backend/python-fastapi` - a reserved name (see plain/stdlib.ts).
@@ -44,12 +46,16 @@ export function defaultBuildDir(moduleName, cwd = process.cwd()) {
 export function projectDirOf(plainFile) {
     const start = dirname(resolve(plainFile));
     for (let dir = start;; dir = dirname(dir)) {
-        if (existsSync(join(dir, "config.yaml")) || existsSync(join(dir, MODULES_DIR)) || hasModuleConfig(dir))
+        if (isProjectDir(dir))
             return dir;
         if (dirname(dir) === dir)
             return start;
     }
 }
+/** Whether a folder says it is a project: it holds a config file or `plain_modules/`. */
+export function isProjectDir(dir) {
+    return existsSync(join(dir, "config.yaml")) || existsSync(join(dir, MODULES_DIR)) || hasModuleConfig(dir);
+}
 /** Whether a folder holds a config file - config.turri.yaml, a stack's config.turri.<stack>.yaml, or one in the old naming - which makes it a project too. */
 function hasModuleConfig(dir) {
     try {

package/dist/regenerate/plain-palette.js

@@ -14,6 +14,7 @@ const DARK = {
         module: { colour: "#f4f7f9" },
         comment: { colour: "#85a3b2", italic: true },
         bullet: { colour: "#85a3b2" },
+        id: { colour: "#5ce1e6", bold: true },
     },
     added: "#5ce1e6",
     removed: "#ff7fa6",
@@ -35,6 +36,7 @@ const LIGHT = {
         module: { colour: "#1e3442" },
         comment: { colour: "#3e5a6b", italic: true },
         bullet: { colour: "#3e5a6b" },
+        id: { colour: "#732553", bold: true },
     },
     added: "#1e3442",
     removed: "#732553",

package/dist/regenerate/prompt.d.ts

@@ -1,22 +1,23 @@
 import { type MarshalledPlainSource, type Specifications } from "../plain/spec.ts";
 import { type LoadedResource } from "./resources.ts";
+import { type TestedSpec } from "./test-kinds.ts";
 import type { JobCases } from "./drift.ts";
 import type { RequiredSpec } from "./state.ts";
 import { type SpecChange } from "./spec-steps.ts";
 /**
  * Functional specs grouped by the module they belong to - in the order the modules are built on
- * one another, the current module marked - and each tagged with its module and its id there. A codebase holds the
- * functionalities of every module it is built on, and each module numbers its own from 1, so
- * "functionality 1" alone is ambiguous: the first listed may be base's 1 and the next top's 3.
+ * one another, the current module marked - and each tagged with its module and its func-id there. A codebase holds the
+ * functionalities of every module it is built on, and a func-id is unique only in its module, so a func-id alone can
+ * be ambiguous: `base` and `app` may each have an `export`.
  * (the reference implementation's implemented functional requirements prompt section, as tags.)
  */
 export declare function functionalitiesByModule(entries: Array<{
     module: string;
-    frid: string;
+    funcId: string;
     spec: string;
 }>, currentModule: string, status?: string): string;
-/** "functionality 3 of module `app`": a functionality, named so that no other module's can be meant. */
-export declare function functionalityOf(frid: string, moduleName: string): string;
+/** "functional spec `app:add-task`": a functional spec, named so that no other module's can be meant. */
+export declare function functionalityOf(funcId: string, moduleName: string): string;
 /**
  * How to read a ***plain specification: what each section is, and what the predefined concepts
  * mean. At the head of every prompt for an agent that builds, tests or judges from a spec - the
@@ -66,6 +67,16 @@ export declare function sectionModules(tree: MarshalledPlainSource, moduleName:
  * when they do not match the items one for one, every item is the current module's.
  */
 export declare function moduleSection(key: string, items: string[], moduleName: string, modules?: SectionModules): string | null;
+/**
+ * The base folder a codebase started from, for its coding agents (base-folder.ts): that it did, and the files that came
+ * from it - code to build on, files to use, or both: the block says neither, for it may be either.
+ */
+export declare function baseFolderBlock(base: {
+    folder: string;
+    files: string[];
+} | undefined): string | null;
+/** The rule for what came from the base folder, for an agent that changes the code: it stays, used where it is. */
+export declare const BASE_FOLDER_RULES: string[];
 export interface SpecDiffPromptInput {
     moduleName: string;
     /** The spec change, as a diff of the .plain files. */
@@ -74,6 +85,8 @@ export interface SpecDiffPromptInput {
     changes?: SpecChange[];
     /** The module's sections and its functional specs, as they stand after the change. */
     specifications: Specifications;
+    /** The func-ids of its functional specs, in order. */
+    funcIds: string[];
     /** Functional specs of the modules this one requires, as they stand after the change. */
     required: RequiredSpec[];
     linkedResources: LoadedResource[];
@@ -84,6 +97,11 @@ export interface SpecDiffPromptInput {
     cases?: JobCases;
     /** The module each definition and req belongs to: see `sectionModules`. */
     modules?: SectionModules;
+    /** The base folder the codebase started from, and the files from it it has still (base-folder.ts). */
+    base?: {
+        folder: string;
+        files: string[];
+    };
 }
 /**
  * The specification a review of some work is given: laid out exactly as the coding agent had it - how to read a
@@ -94,19 +112,32 @@ export interface SpecDiffPromptInput {
 export declare function reviewedSpec(input: {
     moduleName: string;
     specifications: Specifications;
+    /** The func-ids of its functional specs, in order. */
+    funcIds: string[];
     /** Functional specs of the modules this one requires: already in the code. */
     required?: RequiredSpec[];
     /** The change, section by section. */
     change?: string;
     /** The module each definition and req belongs to: see `sectionModules`. */
     modules?: SectionModules;
+    /** The base folder the codebase started from, and the files from it it has still (base-folder.ts). */
+    base?: {
+        folder: string;
+        files: string[];
+    };
 }): string;
+/**
+ * A raw diff of the .plain files without the hunks of test plain files: a coding agent never sees scenarios, which are
+ * the conformance tests'. A test plain file is told by its own frontmatter - `func_id:` - since its folder is the
+ * project's to name.
+ */
+export declare function withoutTestPlainFiles(diff: string): string;
 /** A change in its tag: told section by section, or - when it could not be - the raw diff, with which tag each heading is. */
-export declare function specChangeBlock(change: string): string;
+export declare function specChangeBlock(change: string, scenarios?: boolean): string;
 /**
  * A spec change as an agent reads it: section by section, what was added, what changed - before and now - and what
  * was removed. A definition taken out and put back reworded, or moved, is one change to it, not two. Every item is
- * named so no other module's can be meant: a functional spec by its module and number, and a definition or req of a
+ * named so no other module's can be meant: a functional spec by its module and func-id, and a definition or req of a
  * module below by its module; `moduleName` is the module whose codebase it is - whose own items carry no module.
  */
 export declare function describeSpecChange(changes: SpecChange[], moduleName?: string): string;
@@ -122,9 +153,11 @@ export interface ConformancePromptInput {
     /** What the job does to each functional spec (work.ts): the agent is told case by case. Not given: in general. */
     cases?: JobCases;
     moduleName: string;
-    /** The functionality under test; for a spec change, the last there is - none before the first is written. */
-    frid?: string;
+    /** The functional spec under test, by its func-id; for a spec change, the last there is - none before the first is written. */
+    funcId?: string;
     specifications: Specifications;
+    /** The func-ids of its functional specs, in order. */
+    funcIds: string[];
     linkedResources: LoadedResource[];
     /** File names in the build directory. */
     manifest: string[];
@@ -143,11 +176,8 @@ export interface ConformancePromptInput {
         path: string;
         content: string;
     }>;
-    /** For a spec change: the functionalities it touches, with their acceptance tests - each implemented and labelled. */
-    touched?: Array<{
-        frid: string;
-        acceptanceTests: string[];
-    }>;
+    /** For a spec change: the functional specs it touches, with their scenarios - each carried out and labelled. */
+    touched?: TestedSpec[];
     /** Tests already in the conformance directory, from an earlier version of the spec. */
     existingTests?: string[];
     /** Functional specs of the modules this one requires, transitively. */
@@ -169,18 +199,26 @@ export interface ConformancePromptInput {
  * written from the code can only ever agree with it.
  */
 export declare function buildConformancePrompt(input: ConformancePromptInput): string;
-/** What a conformance test covering no functional spec yet - a definition, a req - is labelled. */
-export declare const CHANGE_LABEL = "conformance tests of the spec";
+/**
+ * Functional specs' scenarios as the conformance agent carries them out: each under its label, the conformance
+ * scenarios and then the acceptance ones, in the tag of each kind.
+ */
+export declare function scenariosBlock(module: string, specs: TestedSpec[]): string | null;
 export interface RegressionFixPromptInput {
     moduleName: string;
-    /** Functionalities built so far, in order. */
-    frids: string[];
+    /** The func-ids of the functional specs built so far, in order. */
+    funcIds: string[];
     specifications: Specifications;
     failure: string;
     /** Functional specs of the modules this one requires, transitively. */
     required?: RequiredSpec[];
     /** The module each definition and req belongs to: see `sectionModules`. */
     modules?: SectionModules;
+    /** The base folder the codebase started from, and the files from it it has still (base-folder.ts). */
+    base?: {
+        folder: string;
+        files: string[];
+    };
 }
 /**
  * Build the prompt for repairing a regression.