@cspeach/cli 1.1.10 → 1.1.12

package/dist/standards/standards-init.js

@@ -34,47 +34,21 @@ export const STANDARDS_INTERVIEW_QUESTIONS = [
         heading: 'Packages for new objects',
         message: 'Package(s) new objects belong in, e.g. ZFI_CORE (Enter to skip):',
     },
-    {
-        key: 'naming',
-        heading: 'Naming style',
-        message: 'Naming style for classes / methods / variables — e.g. "zcl_<area>_<noun>", Hungarian lv_/ls_/lt_ (Enter to skip):',
-    },
-    {
-        key: 'forbidden',
-        heading: 'Forbidden or discouraged statements',
-        message: 'Forbidden or discouraged statements, e.g. "no SELECT *", "no CALL TRANSACTION" (Enter to skip):',
-    },
-    {
-        key: 'atc_variant',
-        heading: 'ATC check variant',
-        message: 'ATC check variant name (Enter to skip):',
-    },
+    // 2026-09-17 (Laeeq): cut from ten questions to four. Naming style,
+    // forbidden statements, ATC variant, transport process, header template
+    // and unit-test expectation were prose for the model only — nothing read
+    // them — and modern ABAP defaults already cover them. Only what the
+    // customer alone knows, and that changes the generated code, is asked.
     {
         key: 'clean_core',
         heading: 'Clean core',
         message: 'Clean-core requirement:',
         choices: ['ABAP Cloud only', 'released APIs preferred', 'classic allowed', '(skip)'],
     },
-    {
-        key: 'transport_process',
-        heading: 'Transport / change process',
-        message: 'Transport / change process, e.g. "ChaRM, one TR per ticket" (Enter to skip):',
-    },
-    {
-        key: 'header_template',
-        heading: 'Code header template',
-        message: 'Required code header / comment template (Enter to skip):',
-    },
-    {
-        key: 'unit_tests',
-        heading: 'Unit tests',
-        message: 'Unit-test expectation:',
-        choices: ['required for all classes', 'business logic only', 'none', '(skip)'],
-    },
     {
         key: 'other',
         heading: 'Anything else',
-        message: 'Anything else CSPeach should follow (Enter to skip):',
+        message: 'Anything else CSPeach should follow, one line (Enter to skip):',
     },
 ];
 /** Header written at the top of an IMPORTED standards document. */
@@ -121,6 +95,66 @@ export async function writeStandardsFile(cwd, content) {
         return homePath;
     }
 }
+/** Sentinel choice in the import dropdown: fall back to a typed path. */
+export const TYPE_A_PATH = '__type_a_path__';
+const STANDARDS_SOURCE_EXTS = ['.md', '.txt', '.docx', '.pdf'];
+const SKIPPED_DIRS = new Set(['node_modules', 'cspeach-out', 'dist', 'build', 'target']);
+function isStandardsSource(name) {
+    const lower = name.toLowerCase();
+    if (lower === 'cspeach-standards.md')
+        return false; // the file we are about to write
+    return STANDARDS_SOURCE_EXTS.some((e) => lower.endsWith(e));
+}
+/**
+ * Files a team's standards document could plausibly be, relative to `cwd`:
+ * .md/.txt/.docx/.pdf at the top level and one level of subfolders
+ * (`docs/abap-guidelines.docx`), sorted by name. Never throws.
+ */
+export async function listStandardsCandidates(cwd) {
+    const out = [];
+    let entries;
+    try {
+        entries = await fs.readdir(cwd, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        if (e.name.startsWith('.'))
+            continue;
+        if (e.isFile()) {
+            if (isStandardsSource(e.name))
+                out.push(e.name);
+            continue;
+        }
+        if (!e.isDirectory() || SKIPPED_DIRS.has(e.name.toLowerCase()))
+            continue;
+        let inner;
+        try {
+            inner = await fs.readdir(path.join(cwd, e.name), { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const c of inner) {
+            if (c.name.startsWith('.') || !c.isFile() || !isStandardsSource(c.name))
+                continue;
+            out.push(`${e.name}/${c.name}`);
+        }
+    }
+    return out.sort((a, b) => a.localeCompare(b));
+}
+/** Read a standards source as text: Word / PDF through document extraction, otherwise UTF-8. */
+export async function readStandardsSource(src) {
+    const lower = src.toLowerCase();
+    if (lower.endsWith('.docx') || lower.endsWith('.pdf')) {
+        const { extractDocument } = await import('../tools/filesystem/extract-document.js');
+        const buf = await fs.readFile(src);
+        const res = await extractDocument(buf, lower.endsWith('.pdf') ? '.pdf' : '.docx', { maxPages: 150 });
+        return res.text;
+    }
+    return fs.readFile(src, 'utf8');
+}
 async function defaultPrompts() {
     const { input, select } = await import('@inquirer/prompts');
     return {
@@ -146,12 +180,34 @@ export async function runStandardsInit(cwd, prompts) {
         default: 'defaults',
     });
     if (route === 'import') {
-        const src = (await p.input({
-            key: 'source',
-            message: 'Path to the standards document (.md or .txt):',
-        })).trim();
+        // 2026-09-17 — offer the files we can see (cwd + one level of
+        // subfolders) as a dropdown before falling back to a typed path, and
+        // accept Word / PDF standards documents, not only .md/.txt.
+        const candidates = await listStandardsCandidates(cwd);
+        let src = '';
+        if (candidates.length > 0) {
+            const picked = await p.select({
+                key: 'source-pick',
+                message: 'Which file holds your standards?',
+                choices: [
+                    ...candidates.map((f) => ({ value: f, name: f })),
+                    { value: TYPE_A_PATH, name: 'Type a path…' },
+                ],
+                default: candidates[0],
+            });
+            // Anything that is not one of the offered files (or the sentinel) falls
+            // through to the typed-path prompt — never treat a stray answer as a path.
+            if (picked !== TYPE_A_PATH && candidates.includes(picked))
+                src = path.resolve(cwd, picked);
+        }
+        if (src.length === 0) {
+            src = (await p.input({
+                key: 'source',
+                message: 'Path to the standards document (.md, .txt, .docx or .pdf):',
+            })).trim();
+        }
         try {
-            const body = await fs.readFile(src, 'utf8');
+            const body = await readStandardsSource(src);
             const content = `${importedStandardsHeader(src)}\n\n${body.trim()}\n`;
             const written = await writeStandardsFile(cwd, content);
             console.log(chalk.green(`✓ Standards imported to ${displayStandardsPath(written, cwd)}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspeach/cli",
-  "version": "1.1.10",
+  "version": "1.1.12",
   "description": "CSPeach — AI-assisted ABAP development CLI. Direct SAP access, 34 skills, safety gates.",
   "keywords": [
     "abap",