filemaker-cli 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 filemaker contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# filemakerx
+
+A cross-platform CLI tool that scaffolds files and folders instantly,
+either from a structure.txt blueprint or an interactive prompt.
+
+Installs as `filemaker-cli`, runs as `filemaker`.
+
+## Install
+
+```
+npm install -g filemaker-cli
+```
+
+## Usage
+
+```
+cd any/project/folder
+filemaker
+```
+
+If a structure.txt file exists in the current directory, filemaker reads
+it and builds everything listed, line by line. Otherwise it asks what
+you want to build.
+
+```
+filemaker --dry-run     show what would be created without touching disk
+filemaker --version     print the installed version
+filemaker --help        show usage info
+```
+
+## structure.txt format
+
+```
+src/
+src/index.js
+src/utils/helpers.js
+.env
+.gitignore
+LICENSE
+README.md
+```
+
+One entry per line. Lines ending in / are always folders. Anything
+starting with a dot, like .env or .gitignore, is always a file. Names
+with a real extension are files too. A handful of common extension-less
+filenames (LICENSE, Dockerfile, Makefile, README, CHANGELOG, and similar)
+are recognized as files as well. Everything else is treated as a folder.
+Blank lines and lines starting with # are ignored.
+
+## Comma mode example
+
+```
+What do you want to build? (Separate items with commas)
+> src/, src/index.js, .env, .gitignore, README.md
+```
+
+## Safety
+
+filemaker only ever creates things inside the folder you ran it from.
+Any entry that tries to escape that folder (using ../ or an absolute
+path) gets skipped and reported, not silently followed.
+
+Running filemaker again over an existing structure won't overwrite
+anything. Items that already exist are left alone and marked
+"[already there]".
+
+## Exiting
+
+Press Ctrl+C at any time to exit cleanly:
+
+```
+Closing safely... Take care!
+```

package/bin/filemaker.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const inquirer = require('inquirer');
+
+const { clearScreen, printMainBanner, printSectionHeader, printExitMessage } = require('../lib/banner');
+const { parseCommaList, parseLines } = require('../lib/parser');
+const { buildAll } = require('../lib/builder');
+const { structureFileExists, readStructureFileLines, STRUCTURE_FILENAME } = require('../lib/structureFile');
+const { parseArgs, printHelp, printVersion } = require('../lib/cli');
+const { checkNodeVersion, filterSafeEntries } = require('../lib/safety');
+
+let exiting = false;
+function handleSigint() {
+  if (exiting) return;
+  exiting = true;
+  printExitMessage();
+  process.exit(0);
+}
+process.on('SIGINT', handleSigint);
+
+async function run() {
+  const flags = parseArgs(process.argv.slice(2));
+
+  if (flags.help) {
+    printHelp();
+    return;
+  }
+
+  if (flags.version) {
+    printVersion();
+    return;
+  }
+
+  if (!checkNodeVersion()) {
+    process.exitCode = 1;
+    return;
+  }
+
+  const cwd = process.cwd();
+
+  clearScreen();
+  printMainBanner();
+
+  if (flags.dryRun) {
+    printSectionHeader('Dry run -- nothing will actually be created');
+    console.log('');
+  }
+
+  let entries = [];
+
+  if (structureFileExists(cwd)) {
+    printSectionHeader(`Found ${STRUCTURE_FILENAME} -- building automatically`);
+    const lines = readStructureFileLines(cwd);
+    entries = parseLines(lines);
+
+    if (entries.length === 0) {
+      console.log(`[!] ${STRUCTURE_FILENAME} was found but contained no valid entries.`);
+      console.log('[!] Nothing to build. Exiting.');
+      return;
+    }
+  } else {
+    printSectionHeader('No structure.txt found -- manual mode');
+
+    const answer = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'items',
+        message: 'What do you want to build? (Separate items with commas)',
+        validate: (input) => {
+          if (!input || input.trim().length === 0) {
+            return 'Please enter at least one file or folder name.';
+          }
+          return true;
+        }
+      }
+    ]);
+
+    entries = parseCommaList(answer.items);
+
+    if (entries.length === 0) {
+      console.log('[!] No valid items were parsed from your input. Exiting.');
+      return;
+    }
+  }
+
+  const { safe, blocked } = filterSafeEntries(entries, cwd);
+
+  if (blocked.length > 0) {
+    console.log('');
+    console.log(`[!] Skipped ${blocked.length} unsafe entr${blocked.length === 1 ? 'y' : 'ies'} (outside the current folder):`);
+    blocked.forEach((entry) => console.log(`[!]   ${entry.name}`));
+  }
+
+  if (safe.length === 0) {
+    console.log('');
+    console.log('[!] Nothing safe left to build. Exiting.');
+    return;
+  }
+
+  console.log('');
+  printSectionHeader(`Building ${safe.length} item(s) in: ${cwd}`);
+  console.log('');
+
+  const results = buildAll(safe, cwd, { dryRun: flags.dryRun });
+
+  const successCount = results.filter((r) => r.success).length;
+  const failCount = results.length - successCount;
+
+  console.log('');
+  printSectionHeader('Summary');
+  console.log(`[+] ${flags.dryRun ? 'Would create' : 'Created'}: ${successCount}`);
+  if (failCount > 0) {
+    console.log(`[!] Failed: ${failCount}`);
+  }
+  console.log('');
+  console.log('Done. Take care!');
+
+  const noFlagsUsed = !flags.dryRun && !flags.help && !flags.version;
+  if (noFlagsUsed) {
+    console.log('');
+    console.log('Tip: run "filemaker --help" to see all available options.');
+  }
+}
+
+run().catch((err) => {
+  console.log('');
+  console.log('[!] Something went wrong:');
+  console.log(`[!] ${err.message}`);
+  process.exit(1);
+});

package/lib/banner.js

@@ -0,0 +1,39 @@
+'use strict';
+
+function clearScreen() {
+  process.stdout.write(process.platform === 'win32' ? '\x1Bc' : '\x1B[2J\x1B[3J\x1B[H');
+}
+
+function printMainBanner() {
+  const banner = [
+    '=========================================',
+    '||                                     ||',
+    '||             F I L E M A K E R        ||',
+    '||      Cross-Platform Scaffold Tool    ||',
+    '||                                     ||',
+    '========================================='
+  ];
+  console.log(banner.join('\n'));
+  console.log('');
+}
+
+function printSectionHeader(title) {
+  const line = '-----------------------------------------';
+  console.log(line);
+  console.log(`  ${title}`);
+  console.log(line);
+}
+
+function printExitMessage() {
+  console.log('');
+  console.log('-----------------------------------------');
+  console.log('  Closing safely... Take care!');
+  console.log('-----------------------------------------');
+}
+
+module.exports = {
+  clearScreen,
+  printMainBanner,
+  printSectionHeader,
+  printExitMessage
+};

package/lib/builder.js

@@ -0,0 +1,73 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function ensureDirSync(targetPath) {
+  fs.mkdirSync(targetPath, { recursive: true });
+}
+
+function ensureFileSync(targetPath) {
+  const dir = path.dirname(targetPath);
+  if (dir && dir !== '.') {
+    ensureDirSync(dir);
+  }
+  if (!fs.existsSync(targetPath)) {
+    fs.writeFileSync(targetPath, '');
+  }
+}
+
+function buildEntry(entry, baseDir, dryRun) {
+  const targetPath = path.join(baseDir, entry.name);
+  const alreadyExists = fs.existsSync(targetPath);
+
+  if (dryRun) {
+    return { ...entry, success: true, alreadyExists, dryRun: true };
+  }
+
+  try {
+    if (entry.type === 'DIR') {
+      ensureDirSync(targetPath);
+    } else {
+      ensureFileSync(targetPath);
+    }
+    return { ...entry, success: true, alreadyExists };
+  } catch (err) {
+    return { ...entry, success: false, error: err.message };
+  }
+}
+
+function buildAll(entries, baseDir, options = {}) {
+  const dryRun = Boolean(options.dryRun);
+  const results = [];
+
+  for (const entry of entries) {
+    const result = buildEntry(entry, baseDir, dryRun);
+    results.push(result);
+
+    const label = result.type === 'DIR' ? '[DIR]' : '[FILE]';
+
+    if (!result.success) {
+      console.log(`[!] FAILED: ${result.name} -- ${result.error}`);
+      continue;
+    }
+
+    if (dryRun) {
+      const tag = result.alreadyExists ? '[exists]' : '[would create]';
+      console.log(`[+] ${label} ${result.name} ${tag}`);
+      continue;
+    }
+
+    const tag = result.alreadyExists ? '[already there]' : '';
+    console.log(`[+] ${label} ${result.name} ${tag}`.trim());
+  }
+
+  return results;
+}
+
+module.exports = {
+  ensureDirSync,
+  ensureFileSync,
+  buildEntry,
+  buildAll
+};

package/lib/cli.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const pkg = require('../package.json');
+
+const HELP_TEXT = `
+filemaker v${pkg.version}
+
+Scaffold files and folders in seconds, right from your terminal.
+
+USAGE
+  filemaker              Build from structure.txt if present, otherwise prompt
+  filemaker --dry-run     Show what would be built without touching disk
+  filemaker --version     Print the installed version
+  filemaker --help        Show this help message
+
+HOW IT WORKS
+  Run filemaker inside any folder. If a structure.txt file exists there,
+  it gets read line by line and everything in it gets built automatically.
+  No structure.txt? You'll be asked what to build, comma separated.
+
+STRUCTURE.TXT FORMAT
+  src/
+  src/index.js
+  .env
+  .gitignore
+  README.md
+
+  One entry per line. A trailing slash always means a folder. Anything
+  starting with a dot is always a file. Anything else with a dot in the
+  name is treated as a file too. Everything else is a folder.
+
+EXAMPLES
+  filemaker
+  filemaker --dry-run
+`;
+
+function parseArgs(argv) {
+  const flags = {
+    help: false,
+    version: false,
+    dryRun: false
+  };
+
+  for (const arg of argv) {
+    if (arg === '--help' || arg === '-h') flags.help = true;
+    if (arg === '--version' || arg === '-v') flags.version = true;
+    if (arg === '--dry-run' || arg === '-d') flags.dryRun = true;
+  }
+
+  return flags;
+}
+
+function printHelp() {
+  console.log(HELP_TEXT);
+}
+
+function printVersion() {
+  console.log(pkg.version);
+}
+
+module.exports = {
+  parseArgs,
+  printHelp,
+  printVersion
+};

package/lib/parser.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const KNOWN_FILES_NO_EXTENSION = new Set([
+  'license',
+  'licence',
+  'dockerfile',
+  'makefile',
+  'readme',
+  'changelog',
+  'authors',
+  'contributing',
+  'procfile',
+  'vagrantfile',
+  'jenkinsfile',
+  'rakefile',
+  'gemfile'
+]);
+
+function classifyEntry(rawEntry) {
+  const trimmed = rawEntry.trim();
+
+  if (!trimmed) {
+    return null;
+  }
+
+  if (trimmed.endsWith('/') || trimmed.endsWith('\\')) {
+    return {
+      name: trimmed.replace(/[/\\]+$/, ''),
+      type: 'DIR'
+    };
+  }
+
+  const isLeadingDot = trimmed.startsWith('.');
+  const nameForCheck = isLeadingDot ? trimmed.slice(1) : trimmed;
+  const hasExtension = /\.[^.]+$/.test(nameForCheck);
+
+  if (isLeadingDot) {
+    return { name: trimmed, type: 'FILE' };
+  }
+
+  if (hasExtension) {
+    return { name: trimmed, type: 'FILE' };
+  }
+
+  const baseName = trimmed.split(/[/\\]/).pop().toLowerCase();
+  if (KNOWN_FILES_NO_EXTENSION.has(baseName)) {
+    return { name: trimmed, type: 'FILE' };
+  }
+
+  return { name: trimmed, type: 'DIR' };
+}
+
+function parseCommaList(input) {
+  return input
+    .split(',')
+    .map((item) => item.trim())
+    .filter((item) => item.length > 0)
+    .map(classifyEntry)
+    .filter(Boolean);
+}
+
+function parseLines(lines) {
+  return lines
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0 && !line.startsWith('#'))
+    .map(classifyEntry)
+    .filter(Boolean);
+}
+
+module.exports = {
+  classifyEntry,
+  parseCommaList,
+  parseLines
+};

package/lib/safety.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const path = require('path');
+
+const MIN_NODE_MAJOR = 14;
+
+function checkNodeVersion() {
+  const major = parseInt(process.versions.node.split('.')[0], 10);
+  if (major < MIN_NODE_MAJOR) {
+    console.log(`[!] filemaker needs Node ${MIN_NODE_MAJOR} or newer. You're running Node ${process.versions.node}.`);
+    console.log('[!] Please update Node and try again.');
+    return false;
+  }
+  return true;
+}
+
+function isPathSafe(baseDir, entryName) {
+  const resolvedBase = path.resolve(baseDir);
+  const resolvedTarget = path.resolve(baseDir, entryName);
+
+  if (path.isAbsolute(entryName)) {
+    return false;
+  }
+
+  if (entryName.split(/[/\\]/).includes('..')) {
+    return false;
+  }
+
+  return resolvedTarget.startsWith(resolvedBase + path.sep) || resolvedTarget === resolvedBase;
+}
+
+function filterSafeEntries(entries, baseDir) {
+  const safe = [];
+  const blocked = [];
+
+  for (const entry of entries) {
+    if (isPathSafe(baseDir, entry.name)) {
+      safe.push(entry);
+    } else {
+      blocked.push(entry);
+    }
+  }
+
+  return { safe, blocked };
+}
+
+module.exports = {
+  checkNodeVersion,
+  isPathSafe,
+  filterSafeEntries
+};

package/lib/structureFile.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const STRUCTURE_FILENAME = 'structure.txt';
+
+function getStructureFilePath(baseDir) {
+  return path.join(baseDir, STRUCTURE_FILENAME);
+}
+
+function structureFileExists(baseDir) {
+  const filePath = getStructureFilePath(baseDir);
+  return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
+}
+
+function readStructureFileLines(baseDir) {
+  const filePath = getStructureFilePath(baseDir);
+  const raw = fs.readFileSync(filePath, 'utf8');
+  return raw.split(/\r?\n/);
+}
+
+module.exports = {
+  STRUCTURE_FILENAME,
+  getStructureFilePath,
+  structureFileExists,
+  readStructureFileLines
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "filemaker-cli",
+  "version": "0.1.1",
+  "description": "A cross-platform CLI tool to scaffold files and folders instantly from a list or a structure.txt blueprint.",
+  "main": "bin/filemaker.js",
+  "bin": {
+    "filemaker": "bin/filemaker.js"
+  },
+  "preferGlobal": true,
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "scripts": {
+    "start": "node bin/filemaker.js"
+  },
+  "keywords": [
+    "cli",
+    "scaffold",
+    "file-generator",
+    "folder-structure",
+    "boilerplate",
+    "project-setup"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "inquirer": "^8.2.6"
+  }
+}